Fuck git

external/capstone/suite/cstest/src/cstest.c

@@ -0,0 +1,112 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#define _XOPEN_SOURCE 500
+#include "../../../utils.h"
+#include "test_run.h"
+#include <capstone/platform.h>
+#include <ftw.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+// Pointer to the file list table
+// Must be a thread local, because we cannot pass arguments to `nftw`.
+// So the found test files can only be saved, very annoyingly,
+// to a global/thread-local mutable variables.
+char ***test_files = NULL;
+uint32_t file_count = 0;
+
+static void help(const char *self)
+{
+	fprintf(stderr, "%s <test-file-dir>/<test-file.yml> ...\n", self);
+}
+
+static int handle_ftree_entry(const char *fpath, const struct stat *sb,
+			      int typeflag, struct FTW *ftwbuf)
+{
+	if (typeflag != FTW_F) {
+		return 0;
+	}
+	const char *suffix = strstr(fpath, ".yaml");
+	if (!suffix || suffix - fpath != strlen(fpath) - 5) {
+		// Misses the .yaml suffix.
+		return 0;
+	}
+
+	file_count++;
+	*test_files = cs_mem_realloc(*test_files, sizeof(char *) * file_count);
+	if (!*test_files) {
+		fprintf(stderr, "[!] realloc failed\n");
+		return -1;
+	}
+	test_files[0][file_count - 1] = cs_strdup(fpath);
+	return 0;
+}
+
+/// Parses the test file paths from the @argv array.
+static void get_tfiles(int argc, const char **argv)
+{
+	for (size_t i = 1; i < argc; ++i) {
+		if (nftw(argv[i], handle_ftree_entry, 20,
+			 FTW_DEPTH | FTW_PHYS) == -1) {
+			fprintf(stderr, "[!] nftw failed.\n");
+			return;
+		}
+	}
+}
+
+void print_test_run_stats(const TestRunStats *stats)
+{
+	printf("\n-----------------------------------------\n");
+	printf("Test run statistics\n\n");
+	printf("Valid files: %" PRId32 "\n", stats->valid_test_files);
+	printf("Invalid files: %" PRId32 "\n", stats->invalid_files);
+	printf("Errors: %" PRId32 "\n\n", stats->errors);
+	printf("Test cases:\n");
+	printf("\tTotal: %" PRId32 "\n", stats->tc_total);
+	printf("\tSuccessful: %" PRId32 "\n", stats->successful);
+	printf("\tSkipped: %" PRId32 "\n", stats->skipped);
+	printf("\tFailed: %" PRId32 "\n", stats->failed);
+	printf("\n\tDecoded instructions: %" PRId32 "\n", stats->decoded_insns);
+	printf("-----------------------------------------\n");
+	printf("\n");
+}
+
+int main(int argc, const char **argv)
+{
+	if (argc < 2 || strcmp(argv[1], "-h") == 0 ||
+	    strcmp(argv[1], "--help") == 0) {
+		help(argv[0]);
+		exit(EXIT_FAILURE);
+	}
+	test_files = malloc(sizeof(char **));
+	*test_files = NULL;
+
+	get_tfiles(argc, argv);
+	if (!*test_files || file_count == 0) {
+		fprintf(stderr, "Arguments are invalid. No files found.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	printf("Test files found: %" PRId32 "\n", file_count);
+	TestRunStats stats = { 0 };
+	TestRunResult res = cstest_run_tests(*test_files, file_count, &stats);
+
+	print_test_run_stats(&stats);
+	if (res == TEST_RUN_ERROR) {
+		fprintf(stderr, "[!] An error occured.\n");
+		exit(EXIT_FAILURE);
+	} else if (res == TEST_RUN_SUCCESS) {
+		printf("[o] All tests succeeded.\n");
+		exit(EXIT_SUCCESS);
+	} else if (res == TEST_RUN_FAILURE) {
+		printf("\nNOTE: Asserts have the actual data on the left side: 'actual' != 'expected'\n\n");
+		fprintf(stderr, "[!] Some tests failed.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	fprintf(stderr, "[!] Unhandled Test Run result\n");
+	exit(EXIT_FAILURE);
+}

external/capstone/suite/cstest/src/helper.c

@@ -0,0 +1,200 @@
+/* Capstone testing regression */
+/* By Do Minh Tuan <tuanit96@gmail.com>, 02-2019 */
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <capstone/platform.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <setjmp.h>
+#include "cmocka.h"
+#include "helper.h"
+
+void add_str(char **src, const char *format, ...)
+{
+	char *tmp;
+	size_t len1, len2;
+	va_list args;
+
+	tmp = (char *)malloc(sizeof(char) * 1000);
+	va_start(args, format);
+	vsprintf(tmp, format, args);
+	va_end(args);
+
+	len1 = strlen(*src);
+	len2 = strlen(tmp);
+
+	*src = (char *)realloc(*src, sizeof(char) * (len1 + len2 + 10));
+	memcpy(*src + len1, tmp, len2 + 1);
+	free(tmp);
+}
+
+void replace_hex(char *src, size_t src_len)
+{
+	char *tmp, *result, *found, *origin, *orig_found;
+	int valid;
+	unsigned long long int value;
+	char *tmp_tmp;
+
+	result = (char *)malloc(sizeof(char));
+	result[0] = '\0';
+	tmp = strdup(src);
+	origin = tmp;
+
+	while ((found = strstr(tmp, "0x")) != NULL) {
+		orig_found = found;
+		found += 2;
+		value = 0;
+		valid = 0;
+
+		tmp_tmp = strndup(tmp, orig_found - tmp);
+		while (*found != '\0' && isxdigit(*found)) {
+			valid = 1;
+			if (*found >= 'a' && *found <= 'f')
+				value = value * 0x10 + (*found - 'a' + 10);
+			else if (*found >= 'A' && *found <= 'F')
+				value = value * 0x10 + (*found - 'A' + 10);
+			else
+				value = value * 0x10 + (*found - '0');
+			found++;
+		}
+
+		if (valid == 1)
+			add_str(&result, "%s%llu", tmp_tmp, value);
+		else
+			add_str(&result, "%s0x", tmp_tmp);
+		tmp = found;
+		free(tmp_tmp);
+	}
+
+	add_str(&result, "%s", tmp);
+	if (strlen(result) >= src_len) {
+		free(result);
+		free(origin);
+		fprintf(stderr,
+			"[  Error   ] --- Buffer Overflow in replace_hex()\n");
+		_fail(__FILE__, __LINE__);
+	}
+
+	strcpy(src, result);
+	free(result);
+	free(origin);
+}
+
+void replace_negative(char *src, size_t src_len, size_t arch_bits)
+{
+	char *tmp, *result, *found, *origin, *orig_found;
+	int cnt, valid;
+	char *value, *tmp_tmp;
+	unsigned short int tmp_short;
+	unsigned int tmp_int;
+	unsigned long int tmp_long;
+
+	result = (char *)malloc(sizeof(char));
+	result[0] = '\0';
+	tmp = strdup(src);
+	origin = tmp;
+
+	while ((found = strstr(tmp, "-")) != NULL) {
+		orig_found = found;
+		found++;
+		valid = 0;
+
+		value = strdup("-");
+		cnt = 2;
+
+		while (*found != '\0' && isdigit(*found)) {
+			valid = 1;
+			value = (char *)realloc(value, cnt + 1);
+			value[cnt - 1] = *found;
+			value[cnt] = '\0';
+			cnt++;
+			found++;
+		}
+
+		tmp_tmp = strndup(tmp, orig_found - tmp);
+		if (valid == 1) {
+			*orig_found = '\0';
+			if (arch_bits == 16) {
+				sscanf(value, "%hu", &tmp_short);
+				add_str(&result, "%s%hu", tmp_tmp, tmp_short);
+			} else if (arch_bits == 32) {
+				sscanf(value, "%u", &tmp_int);
+				add_str(&result, "%s%u", tmp_tmp, tmp_int);
+			} else if (arch_bits == 64) {
+				sscanf(value, "%lu", &tmp_long);
+				add_str(&result, "%s%lu", tmp_tmp, tmp_long);
+			}
+
+		} else
+			add_str(&result, "%s-", tmp_tmp);
+
+		tmp = found;
+		free(value);
+		free(tmp_tmp);
+	}
+
+	add_str(&result, "%s", tmp);
+	if (strlen(result) >= src_len) {
+		fprintf(stderr,
+			"[  Error   ] --- Buffer Overflow in replace_negative()\n");
+		free(result);
+		free(origin);
+		_fail(__FILE__, __LINE__);
+	}
+
+	strcpy(src, result);
+	free(result);
+	free(origin);
+}
+
+void trim_str(char *str)
+{
+	char tmp[MAX_ASM_TXT_MEM];
+	int start, end, j, i;
+
+	start = 0;
+	end = strlen(str) - 1;
+	j = 0;
+	while (start < strlen(str) && isspace(str[start]))
+		start++;
+	while (end >= 0 && isspace(str[end]))
+		end--;
+
+	for (i = start; i <= end; ++i)
+		tmp[j++] = str[i];
+
+	tmp[j] = '\0';
+	strcpy(str, tmp);
+
+	return;
+}
+
+/// Normalizes the usage of spaces in the given string.
+/// It does:
+/// - Replaces '\t' with '\s'
+/// - Replace '\s\s+' with a single space.
+void norm_spaces(char *str)
+{
+	assert(str);
+	char *space_ptr = NULL;
+	while ((space_ptr = strstr(str, "\t")) != NULL) {
+		*space_ptr = ' ';
+	}
+	while ((space_ptr = strstr(str, "  ")) != NULL) {
+		memmove(space_ptr, space_ptr + 1, strlen(space_ptr));
+	}
+	return;
+}
+
+void str_to_lower(char *str)
+{
+	assert(str);
+	for (size_t i = 0; i < strlen(str); ++i)
+		str[i] = tolower(str[i]);
+}

external/capstone/suite/cstest/src/test_case.c

@@ -0,0 +1,352 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include "cmocka.h"
+#include "test_detail.h"
+#include "test_case.h"
+#include "test_compare.h"
+#include "helper.h"
+#include "../../../utils.h"
+#include <stdio.h>
+#include <string.h>
+
+TestInput *test_input_new()
+{
+	TestInput *p = cs_mem_calloc(sizeof(TestInput), 1);
+	assert(p);
+	return p;
+}
+
+void test_input_free(TestInput *test_input)
+{
+	if (!test_input) {
+		return;
+	}
+	cs_mem_free(test_input->name);
+	cs_mem_free(test_input->bytes);
+	cs_mem_free(test_input->arch);
+	for (size_t i = 0; i < test_input->options_count; i++) {
+		cs_mem_free(test_input->options[i]);
+	}
+	cs_mem_free(test_input->options);
+	cs_mem_free(test_input);
+}
+
+TestInput *test_input_clone(TestInput *test_input)
+{
+	assert(test_input);
+	TestInput *ti = test_input_new();
+	ti->address = test_input->address;
+
+	for (size_t i = 0; i < test_input->options_count; i++) {
+		ti->options = cs_mem_realloc(
+			ti->options, sizeof(char *) * (ti->options_count + 1));
+		ti->options[i] = cs_strdup(test_input->options[i]);
+		ti->options_count++;
+	}
+	ti->name = test_input->name ? cs_strdup(test_input->name) : NULL;
+	ti->arch = cs_strdup(test_input->arch);
+	ti->bytes = cs_mem_calloc(sizeof(uint8_t), test_input->bytes_count);
+	ti->bytes_count = test_input->bytes_count;
+	memcpy(ti->bytes, test_input->bytes, test_input->bytes_count);
+	return ti;
+}
+
+char *test_input_stringify(const TestInput *test_input, const char *postfix)
+{
+	size_t msg_len = 2048;
+	char *msg = cs_mem_calloc(sizeof(char), msg_len);
+	char *byte_seq =
+		byte_seq_to_str(test_input->bytes, test_input->bytes_count);
+	if (!msg) {
+		cs_mem_free(byte_seq);
+		return NULL;
+	}
+	char opt_seq[128] = { 0 };
+	str_append_no_realloc(opt_seq, sizeof(opt_seq), "[");
+	for (size_t i = 0; i < test_input->options_count; ++i) {
+		str_append_no_realloc(opt_seq, sizeof(opt_seq), test_input->options[i]);
+		if (i < test_input->options_count - 1) {
+			str_append_no_realloc(opt_seq, sizeof(opt_seq), ", ");
+		}
+	}
+	str_append_no_realloc(opt_seq, sizeof(opt_seq), "]");
+	cs_snprintf(msg, msg_len,
+		    "%sTestInput { arch: %s, options: %s, addr: 0x%" PRIx64
+		    ", bytes: %s }",
+		    postfix, test_input->arch, opt_seq, test_input->address,
+		    byte_seq);
+	cs_mem_free(byte_seq);
+	return msg;
+}
+
+TestInsnData *test_insn_data_new()
+{
+	TestInsnData *p = cs_mem_calloc(sizeof(TestInsnData), 1);
+	assert(p);
+	return p;
+}
+
+void test_insn_data_free(TestInsnData *test_insn_data)
+{
+	if (!test_insn_data) {
+		return;
+	}
+	cs_mem_free(test_insn_data->asm_text);
+	cs_mem_free(test_insn_data->op_str);
+	cs_mem_free(test_insn_data->mnemonic);
+	cs_mem_free(test_insn_data->id);
+	cs_mem_free(test_insn_data->alias_id);
+	test_detail_free(test_insn_data->details);
+	cs_mem_free(test_insn_data);
+}
+
+TestInsnData *test_insn_data_clone(TestInsnData *test_insn_data)
+{
+	assert(test_insn_data);
+	TestInsnData *tid = test_insn_data_new();
+	tid->alias_id = test_insn_data->alias_id ?
+				cs_strdup(test_insn_data->alias_id) :
+				NULL;
+	tid->id = test_insn_data->id ?
+				cs_strdup(test_insn_data->id) :
+				NULL;
+	tid->is_alias = test_insn_data->is_alias;
+	tid->illegal = test_insn_data->illegal;
+	tid->mnemonic = test_insn_data->mnemonic ?
+				cs_strdup(test_insn_data->mnemonic) :
+				NULL;
+	tid->op_str = test_insn_data->op_str ?
+			      cs_strdup(test_insn_data->op_str) :
+			      NULL;
+	tid->asm_text = test_insn_data->asm_text ?
+				cs_strdup(test_insn_data->asm_text) :
+				NULL;
+	if (test_insn_data->details) {
+		tid->details = test_detail_clone(test_insn_data->details);
+	}
+	return tid;
+}
+
+TestExpected *test_expected_new()
+{
+	TestExpected *p = cs_mem_calloc(sizeof(TestExpected), 1);
+	assert(p);
+	return p;
+}
+
+void test_expected_free(TestExpected *test_expected)
+{
+	if (!test_expected) {
+		return;
+	}
+	for (size_t i = 0; i < test_expected->insns_count; i++) {
+		test_insn_data_free(test_expected->insns[i]);
+	}
+	cs_mem_free(test_expected->insns);
+	cs_mem_free(test_expected);
+}
+
+TestExpected *test_expected_clone(TestExpected *test_expected)
+{
+	assert(test_expected);
+	TestExpected *te = test_expected_new();
+	te->insns = cs_mem_calloc(sizeof(TestInsnData *),
+				  test_expected->insns_count);
+	for (size_t i = 0; i < test_expected->insns_count; i++) {
+		te->insns[i] = test_insn_data_clone(test_expected->insns[i]);
+		te->insns_count++;
+	}
+	return te;
+}
+
+/// Compares the given @asm_text to the @expected one.
+/// Because Capstone sometimes deviates from the LLVM syntax
+/// the strings don't need to be the same to be considered a valid match.
+/// E.g. Capstone sometimes prints decimal numbers instead of hexadecimal
+/// for readability.
+static bool compare_asm_text(const char *asm_text, const char *expected,
+			     size_t arch_bits)
+{
+	if (!asm_text || !expected) {
+		fprintf(stderr, "[!] asm_text or expected was NULL\n");
+		return false;
+	}
+	if (strcmp(asm_text, expected) == 0) {
+		return true;
+	}
+	// Normalize both strings
+	char asm_copy[MAX_ASM_TXT_MEM] = { 0 };
+	strncpy(asm_copy, asm_text, MAX_ASM_TXT_MEM - 1);
+	trim_str(asm_copy);
+	replace_hex(asm_copy, sizeof(asm_copy));
+	replace_negative(asm_copy, sizeof(asm_copy), arch_bits);
+	norm_spaces(asm_copy);
+	str_to_lower(asm_copy);
+
+	char expected_copy[MAX_ASM_TXT_MEM] = { 0 };
+	strncpy(expected_copy, expected, MAX_ASM_TXT_MEM - 1);
+	trim_str(expected_copy);
+	replace_hex(expected_copy, sizeof(expected_copy));
+	replace_negative(expected_copy, sizeof(expected_copy), arch_bits);
+	norm_spaces(expected_copy);
+	str_to_lower(expected_copy);
+
+	if (strcmp(asm_copy, expected_copy) == 0) {
+		return true;
+	}
+
+	fprintf(stderr,
+		"Normalized asm-text doesn't match:\n"
+		"decoded:  '%s'\n"
+		"expected: '%s'\n",
+		asm_copy, expected_copy);
+	return false;
+}
+
+static bool ids_match(uint32_t actual, const char *expected) {
+       compare_enum_ret(actual, expected, false);
+       return true;
+}
+
+/// Compares the decoded instructions @insns against the @expected values and returns the result.
+void test_expected_compare(csh *handle, TestExpected *expected, cs_insn *insns,
+			   size_t insns_count, size_t arch_bits)
+{
+	assert_int_equal(insns_count, expected->insns_count);
+	for (size_t i = 0; i < insns_count; ++i) {
+		TestInsnData *expec_data = expected->insns[i];
+		// Test mandatory fields first
+		// The asm text is saved differently for different architectures.
+		// Either all in op_str or split in mnemonic and op_str
+		char asm_text[256] = { 0 };
+		if (insns[i].mnemonic[0] != '\0') {
+			str_append_no_realloc(asm_text, sizeof(asm_text),
+				      insns[i].mnemonic);
+			str_append_no_realloc(asm_text, sizeof(asm_text), " ");
+		}
+		if (insns[i].op_str[0] != '\0') {
+			str_append_no_realloc(asm_text, sizeof(asm_text),
+				      insns[i].op_str);
+		}
+		if (!compare_asm_text(asm_text, expec_data->asm_text,
+				      arch_bits)) {
+			fail_msg("asm-text mismatch\n");
+		}
+
+		// Not mandatory fields. If not initialized they should still match.
+		if (expec_data->id) {
+			assert_true(ids_match((uint32_t)insns[i].id,
+								expec_data->id));
+		}
+		if (expec_data->is_alias != 0) {
+			if (expec_data->is_alias > 0) {
+				assert_true(insns[i].is_alias);
+			} else {
+				assert_false(insns[i].is_alias);
+			}
+		}
+		if (expec_data->illegal != 0) {
+			if (expec_data->illegal > 0) {
+				assert_true(insns[i].illegal);
+			} else {
+				assert_false(insns[i].illegal);
+			}
+		}
+		if (expec_data->alias_id) {
+			assert_true(ids_match((uint32_t)insns[i].alias_id,
+								expec_data->alias_id));
+		}
+		if (expec_data->mnemonic) {
+			assert_string_equal(insns[i].mnemonic,
+					    expec_data->mnemonic);
+		}
+		if (expec_data->op_str) {
+			assert_string_equal(insns[i].op_str,
+					    expec_data->op_str);
+		}
+		if (expec_data->details) {
+			if (!insns[i].detail) {
+				fprintf(stderr, "detail is NULL\n");
+				assert_non_null(insns[i].detail);
+			}
+			assert_true(test_expected_detail(handle, &insns[i],
+							 expec_data->details));
+		}
+	}
+}
+
+TestCase *test_case_new()
+{
+	TestCase *p = cs_mem_calloc(sizeof(TestCase), 1);
+	assert(p);
+	return p;
+}
+
+void test_case_free(TestCase *test_case)
+{
+	if (!test_case) {
+		return;
+	}
+	test_input_free(test_case->input);
+	test_expected_free(test_case->expected);
+	cs_mem_free(test_case->skip_reason);
+	cs_mem_free(test_case);
+}
+
+TestCase *test_case_clone(TestCase *test_case)
+{
+	assert(test_case);
+	TestCase *tc = test_case_new();
+	TestInput *ti = test_input_clone(test_case->input);
+	tc->input = ti;
+	TestExpected *te = test_expected_clone(test_case->expected);
+	tc->expected = te;
+	tc->skip = test_case->skip;
+	if (tc->skip) {
+		tc->skip_reason = strdup(test_case->skip_reason);
+	}
+	return tc;
+}
+
+TestFile *test_file_new()
+{
+	TestFile *p = cs_mem_calloc(sizeof(TestFile), 1);
+	assert(p);
+	return p;
+}
+
+void test_file_free(TestFile *test_file)
+{
+	if (!test_file) {
+		return;
+	}
+
+	for (size_t i = 0; i < test_file->test_cases_count; ++i) {
+		test_case_free(test_file->test_cases[i]);
+	}
+
+	cs_mem_free(test_file->test_cases);
+	cs_mem_free(test_file->filename);
+	test_file->filename = NULL;
+	cs_mem_free(test_file);
+}
+
+TestFile *test_file_clone(TestFile *test_file)
+{
+	assert(test_file);
+	TestFile *tf = test_file_new();
+	tf->filename = test_file->filename ? strdup(test_file->filename) : NULL;
+	tf->test_cases =
+		cs_mem_calloc(sizeof(TestCase *), test_file->test_cases_count);
+
+	for (size_t i = 0; i < test_file->test_cases_count;
+	     i++, tf->test_cases_count++) {
+		TestCase *tc = test_case_clone(test_file->test_cases[i]);
+		tf->test_cases[i] = tc;
+	}
+	return tf;
+}

external/capstone/suite/cstest/src/test_detail.c

@@ -0,0 +1,428 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_detail.h"
+#include "test_compare.h"
+#include <capstone/capstone.h>
+
+TestDetail *test_detail_new()
+{
+	return cs_mem_calloc(sizeof(TestDetail), 1);
+}
+
+TestDetail *test_detail_clone(TestDetail *detail)
+{
+	assert(detail);
+	TestDetail *clone = test_detail_new();
+
+	clone->regs_read =
+		detail->regs_read_count > 0 ?
+			cs_mem_calloc(sizeof(char *), detail->regs_read_count) :
+			NULL;
+	clone->regs_read_count = detail->regs_read_count;
+	for (size_t i = 0; i < detail->regs_read_count; ++i) {
+		clone->regs_read[i] = strdup(detail->regs_read[i]);
+	}
+
+	clone->regs_write = detail->regs_write_count > 0 ?
+				    cs_mem_calloc(sizeof(char *),
+						  detail->regs_write_count) :
+				    NULL;
+	clone->regs_write_count = detail->regs_write_count;
+	for (size_t i = 0; i < detail->regs_write_count; ++i) {
+		clone->regs_write[i] = strdup(detail->regs_write[i]);
+	}
+
+	clone->regs_impl_read =
+		detail->regs_impl_read_count > 0 ?
+			cs_mem_calloc(sizeof(char *),
+				      detail->regs_impl_read_count) :
+			NULL;
+	clone->regs_impl_read_count = detail->regs_impl_read_count;
+	for (size_t i = 0; i < detail->regs_impl_read_count; ++i) {
+		clone->regs_impl_read[i] = strdup(detail->regs_impl_read[i]);
+	}
+
+	clone->regs_impl_write =
+		detail->regs_impl_write_count > 0 ?
+			cs_mem_calloc(sizeof(char *),
+				      detail->regs_impl_write_count) :
+			NULL;
+	clone->regs_impl_write_count = detail->regs_impl_write_count;
+	for (size_t i = 0; i < detail->regs_impl_write_count; ++i) {
+		clone->regs_impl_write[i] = strdup(detail->regs_impl_write[i]);
+	}
+
+	clone->groups =
+		detail->groups_count > 0 ?
+			cs_mem_calloc(sizeof(char *), detail->groups_count) :
+			NULL;
+	clone->groups_count = detail->groups_count;
+	for (size_t i = 0; i < detail->groups_count; ++i) {
+		clone->groups[i] = strdup(detail->groups[i]);
+	}
+
+	if (detail->aarch64) {
+		clone->aarch64 = test_detail_aarch64_clone(detail->aarch64);
+	}
+	if (detail->arm) {
+		clone->arm = test_detail_arm_clone(detail->arm);
+	}
+	if (detail->ppc) {
+		clone->ppc = test_detail_ppc_clone(detail->ppc);
+	}
+	if (detail->tricore) {
+		clone->tricore = test_detail_tricore_clone(detail->tricore);
+	}
+	if (detail->alpha) {
+		clone->alpha = test_detail_alpha_clone(detail->alpha);
+	}
+	if (detail->bpf) {
+		clone->bpf = test_detail_bpf_clone(detail->bpf);
+	}
+	if (detail->hppa) {
+		clone->hppa = test_detail_hppa_clone(detail->hppa);
+	}
+	if (detail->xcore) {
+		clone->xcore = test_detail_xcore_clone(detail->xcore);
+	}
+	if (detail->systemz) {
+		clone->systemz = test_detail_systemz_clone(detail->systemz);
+	}
+	if (detail->sparc) {
+		clone->sparc = test_detail_sparc_clone(detail->sparc);
+	}
+	if (detail->sh) {
+		clone->sh = test_detail_sh_clone(detail->sh);
+	}
+	if (detail->mips) {
+		clone->mips = test_detail_mips_clone(detail->mips);
+	}
+	if (detail->riscv) {
+		clone->riscv = test_detail_riscv_clone(detail->riscv);
+	}
+	if (detail->m680x) {
+		clone->m680x = test_detail_m680x_clone(detail->m680x);
+	}
+	if (detail->tms320c64x) {
+		clone->tms320c64x =
+			test_detail_tms320c64x_clone(detail->tms320c64x);
+	}
+	if (detail->mos65xx) {
+		clone->mos65xx = test_detail_mos65xx_clone(detail->mos65xx);
+	}
+	if (detail->evm) {
+		clone->evm = test_detail_evm_clone(detail->evm);
+	}
+	if (detail->loongarch) {
+		clone->loongarch =
+			test_detail_loongarch_clone(detail->loongarch);
+	}
+	if (detail->wasm) {
+		clone->wasm = test_detail_wasm_clone(detail->wasm);
+	}
+	if (detail->x86) {
+		clone->x86 = test_detail_x86_clone(detail->x86);
+	}
+	if (detail->m68k) {
+		clone->m68k = test_detail_m68k_clone(detail->m68k);
+	}
+	if (detail->xtensa) {
+		clone->xtensa = test_detail_xtensa_clone(detail->xtensa);
+	}
+	if (detail->arc) {
+		clone->arc = test_detail_arc_clone(detail->arc);
+	}
+
+	return clone;
+}
+
+void test_detail_free(TestDetail *detail)
+{
+	if (!detail) {
+		return;
+	}
+
+	for (size_t i = 0; i < detail->regs_read_count; ++i) {
+		cs_mem_free(detail->regs_read[i]);
+	}
+	cs_mem_free(detail->regs_read);
+
+	for (size_t i = 0; i < detail->regs_write_count; ++i) {
+		cs_mem_free(detail->regs_write[i]);
+	}
+	cs_mem_free(detail->regs_write);
+
+	for (size_t i = 0; i < detail->regs_impl_read_count; ++i) {
+		cs_mem_free(detail->regs_impl_read[i]);
+	}
+	cs_mem_free(detail->regs_impl_read);
+
+	for (size_t i = 0; i < detail->regs_impl_write_count; ++i) {
+		cs_mem_free(detail->regs_impl_write[i]);
+	}
+	cs_mem_free(detail->regs_impl_write);
+
+	for (size_t i = 0; i < detail->groups_count; ++i) {
+		cs_mem_free(detail->groups[i]);
+	}
+	cs_mem_free(detail->groups);
+
+	if (detail->aarch64) {
+		test_detail_aarch64_free(detail->aarch64);
+	}
+	if (detail->arm) {
+		test_detail_arm_free(detail->arm);
+	}
+	if (detail->ppc) {
+		test_detail_ppc_free(detail->ppc);
+	}
+	if (detail->tricore) {
+		test_detail_tricore_free(detail->tricore);
+	}
+	if (detail->alpha) {
+		test_detail_alpha_free(detail->alpha);
+	}
+	if (detail->hppa) {
+		test_detail_hppa_free(detail->hppa);
+	}
+	if (detail->bpf) {
+		test_detail_bpf_free(detail->bpf);
+	}
+	if (detail->xcore) {
+		test_detail_xcore_free(detail->xcore);
+	}
+	if (detail->systemz) {
+		test_detail_systemz_free(detail->systemz);
+	}
+	if (detail->sparc) {
+		test_detail_sparc_free(detail->sparc);
+	}
+	if (detail->sh) {
+		test_detail_sh_free(detail->sh);
+	}
+	if (detail->mips) {
+		test_detail_mips_free(detail->mips);
+	}
+	if (detail->riscv) {
+		test_detail_riscv_free(detail->riscv);
+	}
+	if (detail->m680x) {
+		test_detail_m680x_free(detail->m680x);
+	}
+	if (detail->tms320c64x) {
+		test_detail_tms320c64x_free(detail->tms320c64x);
+	}
+	if (detail->mos65xx) {
+		test_detail_mos65xx_free(detail->mos65xx);
+	}
+	if (detail->evm) {
+		test_detail_evm_free(detail->evm);
+	}
+	if (detail->loongarch) {
+		test_detail_loongarch_free(detail->loongarch);
+	}
+	if (detail->wasm) {
+		test_detail_wasm_free(detail->wasm);
+	}
+	if (detail->x86) {
+		test_detail_x86_free(detail->x86);
+	}
+	if (detail->m68k) {
+		test_detail_m68k_free(detail->m68k);
+	}
+	if (detail->xtensa) {
+		test_detail_xtensa_free(detail->xtensa);
+	}	
+	if (detail->arc) {
+		test_detail_arc_free(detail->arc);
+	}
+
+	cs_mem_free(detail);
+}
+
+static bool test_reg_rw_access(csh *handle, const cs_insn *insn,
+			       TestDetail *expected)
+{
+	assert(handle && insn && expected);
+	if (expected->regs_read_count <= 0 && expected->regs_write_count <= 0) {
+		return true;
+	}
+
+	cs_regs regs_read, regs_write;
+	uint8_t regs_read_count, regs_write_count;
+	cs_err err = cs_regs_access(*handle, insn, regs_read, &regs_read_count,
+				    regs_write, &regs_write_count);
+	if (err != CS_ERR_OK) {
+		fprintf(stderr, "cs_regs_access() failed with '%s'\n",
+			cs_strerror(err));
+		return false;
+	}
+
+	if (expected->regs_read_count > 0) {
+		compare_uint32_ret(regs_read_count, expected->regs_read_count,
+				   false);
+		for (size_t i = 0; i < regs_read_count; ++i) {
+			compare_reg_ret(*handle, regs_read[i],
+					expected->regs_read[i], false);
+		}
+	}
+
+	if (expected->regs_write_count > 0) {
+		compare_uint32_ret(regs_write_count, expected->regs_write_count,
+				   false);
+		for (size_t i = 0; i < regs_write_count; ++i) {
+			compare_reg_ret(*handle, regs_write[i],
+					expected->regs_write[i], false);
+		}
+	}
+	return true;
+}
+
+static bool test_impl_reg_rw_access(csh *handle, const cs_insn *insn,
+				    TestDetail *expected)
+{
+	assert(handle && insn && expected);
+	if (expected->regs_impl_read_count <= 0 &&
+	    expected->regs_impl_write_count <= 0) {
+		return true;
+	}
+	cs_detail *actual = insn->detail;
+
+	// Test exclusively the implicitly read or written register.
+	if (expected->regs_impl_read_count > 0) {
+		compare_uint32_ret(actual->regs_read_count,
+				   expected->regs_impl_read_count, false);
+		for (size_t i = 0; i < actual->regs_read_count; ++i) {
+			compare_reg_ret(*handle, actual->regs_read[i],
+					expected->regs_impl_read[i], false);
+		}
+	}
+
+	if (expected->regs_impl_write_count > 0) {
+		compare_uint32_ret(actual->regs_write_count,
+				   expected->regs_impl_write_count, false);
+		for (size_t i = 0; i < actual->regs_write_count; ++i) {
+			compare_reg_ret(*handle, actual->regs_write[i],
+					expected->regs_impl_write[i], false);
+		}
+	}
+	return true;
+}
+
+bool test_expected_detail(csh *handle, const cs_insn *insn,
+			  TestDetail *expected)
+{
+	assert(handle && insn && insn->detail && expected);
+	cs_detail *actual = insn->detail;
+
+	if (!test_reg_rw_access(handle, insn, expected)) {
+		return false;
+	}
+
+	if (!test_impl_reg_rw_access(handle, insn, expected)) {
+		return false;
+	}
+
+	if (expected->groups_count > 0) {
+		compare_uint32_ret(actual->groups_count, expected->groups_count,
+				   false);
+		for (size_t i = 0; i < actual->groups_count; ++i) {
+			if (strings_match(cs_group_name(*handle,
+							actual->groups[i]),
+					  expected->groups[i])) {
+				continue;
+			}
+			compare_enum_ret(actual->groups[i], expected->groups[i],
+					 false);
+		}
+	}
+
+	if (expected->aarch64) {
+		return test_expected_aarch64(handle, &actual->aarch64,
+					     expected->aarch64);
+	}
+	if (expected->arm) {
+		return test_expected_arm(handle, &actual->arm, expected->arm);
+	}
+	if (expected->ppc) {
+		return test_expected_ppc(handle, &actual->ppc, expected->ppc);
+	}
+	if (expected->tricore) {
+		return test_expected_tricore(handle, &actual->tricore,
+					     expected->tricore);
+	}
+	if (expected->alpha) {
+		return test_expected_alpha(handle, &actual->alpha,
+					   expected->alpha);
+	}
+	if (expected->bpf) {
+		return test_expected_bpf(handle, &actual->bpf, expected->bpf);
+	}
+	if (expected->hppa) {
+		return test_expected_hppa(handle, &actual->hppa,
+					  expected->hppa);
+	}
+	if (expected->xcore) {
+		return test_expected_xcore(handle, &actual->xcore,
+					   expected->xcore);
+	}
+	if (expected->systemz) {
+		return test_expected_systemz(handle, &actual->systemz,
+					     expected->systemz);
+	}
+	if (expected->sparc) {
+		return test_expected_sparc(handle, &actual->sparc,
+					   expected->sparc);
+	}
+	if (expected->sh) {
+		return test_expected_sh(handle, &actual->sh, expected->sh);
+	}
+	if (expected->mips) {
+		return test_expected_mips(handle, &actual->mips,
+					  expected->mips);
+	}
+	if (expected->riscv) {
+		return test_expected_riscv(handle, &actual->riscv,
+					   expected->riscv);
+	}
+	if (expected->m680x) {
+		return test_expected_m680x(handle, &actual->m680x,
+					   expected->m680x);
+	}
+	if (expected->tms320c64x) {
+		return test_expected_tms320c64x(handle, &actual->tms320c64x,
+						expected->tms320c64x);
+	}
+	if (expected->mos65xx) {
+		return test_expected_mos65xx(handle, &actual->mos65xx,
+					     expected->mos65xx);
+	}
+	if (expected->evm) {
+		return test_expected_evm(handle, &actual->evm, expected->evm);
+	}
+	if (expected->loongarch) {
+		return test_expected_loongarch(handle, &actual->loongarch,
+					       expected->loongarch);
+	}
+	if (expected->wasm) {
+		return test_expected_wasm(handle, &actual->wasm,
+					  expected->wasm);
+	}
+	if (expected->x86) {
+		return test_expected_x86(handle, &actual->x86, expected->x86);
+	}
+	if (expected->m68k) {
+		return test_expected_m68k(handle, &actual->m68k,
+					  expected->m68k);
+	}
+	if (expected->xtensa) {
+		return test_expected_xtensa(handle, &actual->xtensa,
+					    expected->xtensa);
+	}
+	if (expected->arc) {
+		return test_expected_arc(handle, &actual->arc,
+					  expected->arc);
+	}
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_aarch64.c

@@ -0,0 +1,260 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_aarch64.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailAArch64 *test_detail_aarch64_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailAArch64), 1);
+}
+
+void test_detail_aarch64_free(TestDetailAArch64 *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_aarch64_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->cc);
+	cs_mem_free(detail);
+}
+
+TestDetailAArch64 *test_detail_aarch64_clone(TestDetailAArch64 *detail)
+{
+	TestDetailAArch64 *clone = test_detail_aarch64_new();
+	clone->cc = detail->cc ? strdup(detail->cc) : NULL;
+	clone->update_flags = detail->update_flags;
+	clone->post_indexed = detail->post_indexed;
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailAArch64Op *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_aarch64_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailAArch64Op *test_detail_aarch64_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailAArch64Op), 1);
+}
+
+TestDetailAArch64Op *test_detail_aarch64_op_clone(TestDetailAArch64Op *op)
+{
+	TestDetailAArch64Op *clone = test_detail_aarch64_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->sub_type = op->sub_type ? strdup(op->sub_type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_index = op->mem_index ? strdup(op->mem_index) : NULL;
+	clone->shift_type = op->shift_type ? strdup(op->shift_type) : NULL;
+	clone->ext = op->ext ? strdup(op->ext) : NULL;
+	clone->vas = op->vas ? strdup(op->vas) : NULL;
+	clone->imm = op->imm;
+	clone->sme = op->sme ? test_detail_aarch64_op_sme_clone(op->sme) : NULL;
+	clone->pred_reg = op->pred_reg ? strdup(op->pred_reg) : NULL;
+	clone->pred_vec_select =
+		op->pred_vec_select ? strdup(op->pred_vec_select) : NULL;
+	clone->pred_imm_index = op->pred_imm_index;
+	clone->pred_imm_index_set = op->pred_imm_index_set;
+	clone->mem_disp = op->mem_disp;
+	clone->imm_range_first = op->imm_range_first;
+	clone->imm_range_offset = op->imm_range_offset;
+	clone->fp = op->fp;
+	clone->fp_set = op->fp_set;
+	clone->sys_raw_val = op->sys_raw_val;
+	clone->shift_value = op->shift_value;
+	clone->is_vreg = op->is_vreg;
+	clone->vector_index = op->vector_index;
+	clone->vector_index_is_set = op->vector_index_is_set;
+	clone->is_list_member = op->is_list_member;
+
+	return clone;
+}
+
+void test_detail_aarch64_op_free(TestDetailAArch64Op *op)
+{
+	if (!op) {
+		return;
+	}
+	test_detail_aarch64_op_sme_free(op->sme);
+	cs_mem_free(op->type);
+	cs_mem_free(op->sub_type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_index);
+	cs_mem_free(op->shift_type);
+	cs_mem_free(op->ext);
+	cs_mem_free(op->vas);
+	cs_mem_free(op->pred_reg);
+	cs_mem_free(op->pred_vec_select);
+	cs_mem_free(op);
+}
+
+TestDetailAArch64SME *test_detail_aarch64_op_sme_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailAArch64SME), 1);
+}
+
+TestDetailAArch64SME *test_detail_aarch64_op_sme_clone(TestDetailAArch64SME *sme)
+{
+	TestDetailAArch64SME *clone = test_detail_aarch64_op_sme_new();
+
+	clone->type = sme->type ? strdup(sme->type) : NULL;
+	clone->tile = sme->tile ? strdup(sme->tile) : NULL;
+	clone->slice_reg = sme->slice_reg ? strdup(sme->slice_reg) : NULL;
+	clone->slice_offset_imm = sme->slice_offset_imm;
+	clone->slice_offset_ir_first = sme->slice_offset_ir_first;
+	clone->slice_offset_ir_offset = sme->slice_offset_ir_offset;
+	clone->slice_offset_ir_set = sme->slice_offset_ir_set;
+	clone->has_range_offset = sme->has_range_offset;
+	clone->is_vertical = sme->is_vertical;
+
+	return clone;
+}
+
+void test_detail_aarch64_op_sme_free(TestDetailAArch64SME *sme)
+{
+	if (!sme) {
+		return;
+	}
+	cs_mem_free(sme->type);
+	cs_mem_free(sme->tile);
+	cs_mem_free(sme->slice_reg);
+	cs_mem_free(sme);
+}
+
+bool test_expected_aarch64(csh *handle, cs_aarch64 *actual,
+			   TestDetailAArch64 *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_enum_ret(actual->cc, expected->cc, false);
+	compare_tbool_ret(actual->update_flags, expected->update_flags, false);
+	compare_tbool_ret(actual->post_index, expected->post_indexed, false);
+
+	if (expected->operands_count == 0) {
+		return true;
+	}
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		cs_aarch64_op *op = &actual->operands[i];
+		TestDetailAArch64Op *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"AArch64 op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case AARCH64_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case AARCH64_OP_IMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		case AARCH64_OP_IMM_RANGE:
+			compare_int8_ret(op->imm_range.first,
+					 eop->imm_range_first, false);
+			compare_int8_ret(op->imm_range.offset,
+					 eop->imm_range_offset, false);
+			break;
+		case AARCH64_OP_FP:
+			compare_fp_ret(op->fp, eop->fp, false);
+			break;
+		case AARCH64_OP_SYSREG:
+			compare_enum_ret(op->sysop.sub_type, eop->sub_type,
+					 false);
+			compare_int_ret(op->sysop.reg.raw_val,
+					   eop->sys_raw_val, false);
+			break;
+		case AARCH64_OP_SYSIMM:
+			compare_enum_ret(op->sysop.sub_type, eop->sub_type,
+					 false);
+			compare_int_ret(op->sysop.imm.raw_val,
+					   eop->sys_raw_val, false);
+			if (eop->fp_set) {
+				compare_fp_ret(op->fp, eop->fp, false);
+			}
+			break;
+		case AARCH64_OP_SYSALIAS:
+			compare_enum_ret(op->sysop.sub_type, eop->sub_type,
+					 false);
+			compare_int_ret(op->sysop.alias.raw_val,
+					   eop->sys_raw_val, false);
+			break;
+		case AARCH64_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+			compare_int32_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		case AARCH64_OP_PRED:
+			compare_reg_ret(*handle, op->pred.reg, eop->pred_reg,
+					false);
+			compare_reg_ret(*handle, op->pred.vec_select, eop->pred_vec_select,
+					false);
+			if (eop->pred_imm_index_set) {
+				compare_int32_ret(op->pred.imm_index, eop->pred_imm_index, false);
+			} else {
+				assert(eop->pred_imm_index == 0);
+			}
+			break;
+		case AARCH64_OP_SME:
+			compare_enum_ret(op->sme.type, eop->sme->type,
+					false);
+			compare_reg_ret(*handle, op->sme.tile, eop->sme->tile,
+					false);
+			compare_reg_ret(*handle, op->sme.slice_reg, eop->sme->slice_reg,
+					false);
+			compare_tbool_ret(op->sme.has_range_offset, eop->sme->has_range_offset,
+					false);
+			compare_tbool_ret(op->sme.is_vertical, eop->sme->is_vertical,
+					false);
+			if (eop->sme->slice_offset_imm) {
+				compare_int32_ret(op->sme.slice_offset.imm, eop->sme->slice_offset_imm, false);
+			}
+			if (eop->sme->slice_offset_ir_set) {
+				compare_int32_ret(op->sme.slice_offset.imm_range.first, eop->sme->slice_offset_ir_first, false);
+				compare_int32_ret(op->sme.slice_offset.imm_range.offset, eop->sme->slice_offset_ir_offset, false);
+			} else {
+				assert(eop->sme->slice_offset_ir_first == 0 && eop->sme->slice_offset_ir_offset == 0);
+			}
+			break;
+		}
+
+		compare_enum_ret(op->shift.type, eop->shift_type, false);
+		compare_uint32_ret(op->shift.value, eop->shift_value, false);
+		compare_enum_ret(op->ext, eop->ext, false);
+
+		compare_enum_ret(op->vas, eop->vas, false);
+		compare_tbool_ret(op->is_vreg, eop->is_vreg, false);
+		if (eop->vector_index_is_set) {
+			compare_int32_ret(op->vector_index, eop->vector_index,
+					  false);
+		} else {
+			assert(eop->vector_index == 0);
+		}
+
+		compare_tbool_ret(op->is_list_member, eop->is_list_member,
+				  false);
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_alpha.c

@@ -0,0 +1,99 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_alpha.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailAlpha *test_detail_alpha_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailAlpha), 1);
+}
+
+void test_detail_alpha_free(TestDetailAlpha *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_alpha_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailAlpha *test_detail_alpha_clone(const TestDetailAlpha *detail)
+{
+	TestDetailAlpha *clone = test_detail_alpha_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailAlphaOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_alpha_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailAlphaOp *test_detail_alpha_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailAlphaOp), 1);
+}
+
+TestDetailAlphaOp *test_detail_alpha_op_clone(const TestDetailAlphaOp *op)
+{
+	TestDetailAlphaOp *clone = test_detail_alpha_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+
+	return clone;
+}
+
+void test_detail_alpha_op_free(TestDetailAlphaOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op);
+}
+
+bool test_expected_alpha(csh *handle, const cs_alpha *actual,
+			 const TestDetailAlpha *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_alpha_op *op = &actual->operands[i];
+		TestDetailAlphaOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"alpha op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case ALPHA_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case ALPHA_OP_IMM:
+			compare_int32_ret(op->imm, eop->imm, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_arc.c

@@ -0,0 +1,99 @@
+// Copyright © 2024 Sibirtsev Dmitry <sibirtsevdl@gmail.com>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_arc.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailARC *test_detail_arc_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailARC), 1);
+}
+
+void test_detail_arc_free(TestDetailARC *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_arc_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailARC *test_detail_arc_clone(const TestDetailARC *detail)
+{
+	TestDetailARC *clone = test_detail_arc_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailARCOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_arc_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailARCOp *test_detail_arc_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailARCOp), 1);
+}
+
+TestDetailARCOp *test_detail_arc_op_clone(const TestDetailARCOp *op)
+{
+	TestDetailARCOp *clone = test_detail_arc_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+
+	return clone;
+}
+
+void test_detail_arc_op_free(TestDetailARCOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op);
+}
+
+bool test_expected_arc(csh *handle, const cs_arc *actual,
+			 const TestDetailARC *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_arc_op *op = &actual->operands[i];
+		TestDetailARCOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"arc op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case ARC_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case ARC_OP_IMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_arm.c

@@ -0,0 +1,256 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_arm.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailARM *test_detail_arm_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailARM), 1);
+}
+
+void test_detail_arm_free(TestDetailARM *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_arm_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->vector_data);
+	cs_mem_free(detail->cps_mode);
+	cs_mem_free(detail->cps_flag);
+	cs_mem_free(detail->cc);
+	cs_mem_free(detail->vcc);
+	cs_mem_free(detail->mem_barrier);
+	cs_mem_free(detail);
+}
+
+TestDetailARM *test_detail_arm_clone(TestDetailARM *detail)
+{
+	TestDetailARM *clone = test_detail_arm_new();
+	clone->update_flags = detail->update_flags;
+	clone->post_indexed = detail->post_indexed;
+	clone->vector_data = detail->vector_data ? strdup(detail->vector_data) : NULL;
+	clone->cps_mode = detail->cps_mode ? strdup(detail->cps_mode) : NULL;
+	clone->cps_flag = detail->cps_flag ? strdup(detail->cps_flag) : NULL;
+	clone->cc = detail->cc ? strdup(detail->cc) : NULL;
+	clone->vcc = detail->vcc ? strdup(detail->vcc) : NULL;
+	clone->mem_barrier = detail->mem_barrier ? strdup(detail->mem_barrier) : NULL;
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailARMOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_arm_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailARMOp *test_detail_arm_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailARMOp), 1);
+}
+
+TestDetailARMOp *test_detail_arm_op_clone(TestDetailARMOp *op)
+{
+	TestDetailARMOp *clone = test_detail_arm_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->setend = op->setend ? strdup(op->setend) : NULL;
+	clone->pred = op->pred;
+	clone->fp = op->fp;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_index = op->mem_index ? strdup(op->mem_index) : NULL;
+	clone->mem_scale = op->mem_scale;
+	clone->mem_disp = op->mem_disp;
+	clone->mem_align = op->mem_align;
+	clone->sys_reg = op->sys_reg ? strdup(op->sys_reg) : NULL;
+	clone->sys_psr_bits_count = op->sys_psr_bits_count;
+	clone->sys_psr_bits =
+		op->sys_psr_bits_count == 0 ?
+			NULL :
+			cs_mem_calloc(sizeof(char *), op->sys_psr_bits_count);
+	for (size_t i = 0; i < op->sys_psr_bits_count; ++i) {
+		clone->sys_psr_bits[i] = strdup(op->sys_psr_bits[i]);
+	}
+	clone->sys_sysm = op->sys_sysm;
+	clone->sys_msr_mask = op->sys_msr_mask;
+	clone->shift_type = op->shift_type ? strdup(op->shift_type) : NULL;
+	clone->shift_value = op->shift_value;
+	clone->neon_lane = op->neon_lane;
+	clone->vector_index = op->vector_index;
+	clone->vector_index_is_set = op->vector_index_is_set;
+	clone->subtracted = op->subtracted;
+
+	return clone;
+}
+
+void test_detail_arm_op_free(TestDetailARMOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->setend);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_index);
+	cs_mem_free(op->shift_type);
+	cs_mem_free(op->sys_reg);
+	if (op->sys_psr_bits_count != 0) {
+		for (size_t i = 0; i < op->sys_psr_bits_count; ++i) {
+			cs_mem_free(op->sys_psr_bits[i]);
+		}
+		cs_mem_free(op->sys_psr_bits);
+	}
+	cs_mem_free(op);
+}
+
+bool test_expected_arm(csh *handle, cs_arm *actual, TestDetailARM *expected)
+{
+	assert(handle && actual && expected);
+
+	if (expected->vector_size) {
+		compare_int_ret(actual->vector_size, expected->vector_size,
+				false);
+	}
+	compare_enum_ret(actual->vector_data, expected->vector_data, false);
+	compare_enum_ret(actual->cps_flag, expected->cps_flag, false);
+	compare_enum_ret(actual->cps_mode, expected->cps_mode, false);
+	compare_enum_ret(actual->cc, expected->cc, false);
+	compare_enum_ret(actual->vcc, expected->vcc, false);
+	compare_enum_ret(actual->mem_barrier, expected->mem_barrier, false);
+	if (expected->pred_mask) {
+		compare_uint8_ret(actual->pred_mask, expected->pred_mask,
+				  false);
+	}
+	compare_tbool_ret(actual->usermode, expected->usermode, false);
+	compare_tbool_ret(actual->update_flags, expected->update_flags, false);
+	compare_tbool_ret(actual->post_index, expected->post_indexed, false);
+
+	if (expected->operands_count == 0) {
+		return true;
+	}
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		cs_arm_op *op = &actual->operands[i];
+		TestDetailARMOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"arm op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case ARM_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case ARM_OP_IMM:
+		case ARM_OP_PIMM:
+		case ARM_OP_CIMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		case ARM_OP_PRED:
+			compare_int_ret(op->pred, eop->pred, false);
+			break;
+		case ARM_OP_SETEND:
+			compare_enum_ret(op->setend, eop->setend, false);
+			break;
+		case ARM_OP_FP:
+			compare_fp_ret(op->fp, eop->fp, false);
+			break;
+		case ARM_OP_SYSREG:
+			compare_enum_ret(op->sysop.reg.mclasssysreg,
+					 eop->sys_reg, false);
+			if (eop->sys_sysm) {
+				compare_uint16_ret(op->sysop.sysm,
+						   eop->sys_sysm, false);
+			}
+			if (eop->sys_msr_mask) {
+				compare_uint8_ret(op->sysop.msr_mask,
+						  eop->sys_msr_mask, false);
+			}
+			break;
+		case ARM_OP_BANKEDREG:
+			compare_enum_ret(op->sysop.reg.bankedreg, eop->sys_reg,
+					 false);
+			if (eop->sys_sysm) {
+				compare_uint16_ret(op->sysop.sysm,
+						   eop->sys_sysm, false);
+			}
+			if (eop->sys_msr_mask) {
+				compare_uint8_ret(op->sysop.msr_mask,
+						  eop->sys_msr_mask, false);
+			}
+			break;
+		case ARM_OP_SPSR:
+		case ARM_OP_CPSR:
+			compare_bit_flags_ret(op->sysop.psr_bits,
+					      eop->sys_psr_bits,
+					      eop->sys_psr_bits_count, false);
+			if (eop->sys_sysm) {
+				compare_uint16_ret(op->sysop.sysm,
+						   eop->sys_sysm, false);
+			}
+			if (eop->sys_msr_mask) {
+				compare_uint8_ret(op->sysop.msr_mask,
+						  eop->sys_msr_mask, false);
+			}
+			break;
+		case ARM_OP_SYSM:
+			if (eop->sys_sysm) {
+				compare_uint16_ret(op->sysop.sysm,
+						   eop->sys_sysm, false);
+			}
+			if (eop->sys_msr_mask) {
+				compare_uint8_ret(op->sysop.msr_mask,
+						  eop->sys_msr_mask, false);
+			}
+			break;
+		case ARM_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+			compare_int_ret(op->mem.disp, eop->mem_disp, false);
+			compare_uint_ret(op->mem.align, eop->mem_align, false);
+			if (eop->mem_scale) {
+				compare_int_ret(op->mem.scale, eop->mem_scale, false);
+			}
+			break;
+		}
+
+		compare_enum_ret(op->shift.type, eop->shift_type, false);
+		if (eop->shift_value) {
+			compare_uint32_ret(op->shift.value, eop->shift_value,
+					   false);
+		}
+		if (eop->neon_lane) {
+			compare_uint8_ret(op->neon_lane, eop->neon_lane, false);
+		}
+
+		if (eop->vector_index_is_set) {
+			compare_int32_ret(op->vector_index, eop->vector_index,
+					  false);
+		} else {
+			assert(eop->vector_index == 0);
+		}
+		compare_tbool_ret(op->subtracted, eop->subtracted, false);
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_bpf.c

@@ -0,0 +1,129 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_bpf.h"
+#include <capstone/bpf.h>
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailBPF *test_detail_bpf_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailBPF), 1);
+}
+
+void test_detail_bpf_free(TestDetailBPF *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_bpf_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailBPF *test_detail_bpf_clone(const TestDetailBPF *detail)
+{
+	TestDetailBPF *clone = test_detail_bpf_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailBPFOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_bpf_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailBPFOp *test_detail_bpf_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailBPFOp), 1);
+}
+
+TestDetailBPFOp *test_detail_bpf_op_clone(const TestDetailBPFOp *op)
+{
+	TestDetailBPFOp *clone = test_detail_bpf_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->off = op->off;
+	clone->mmem = op->mmem;
+	clone->msh = op->msh;
+	clone->ext = op->ext ? strdup(op->ext) : NULL;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_disp = op->mem_disp;
+	clone->is_pkt = op->is_pkt;
+	clone->is_signed = op->is_signed;
+
+	return clone;
+}
+
+void test_detail_bpf_op_free(TestDetailBPFOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->ext);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op);
+}
+
+bool test_expected_bpf(csh *handle, const cs_bpf *actual,
+		       const TestDetailBPF *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_bpf_op *op = &actual->operands[i];
+		TestDetailBPFOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		compare_tbool_ret(op->is_pkt, eop->is_pkt, false);
+		compare_tbool_ret(op->is_signed, eop->is_signed, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"bpf op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case BPF_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case BPF_OP_IMM:
+			compare_uint64_ret(op->imm, eop->imm, false);
+			break;
+		case BPF_OP_OFF:
+			compare_uint32_ret(op->off, eop->off, false);
+			break;
+		case BPF_OP_MMEM:
+			compare_uint32_ret(op->mmem, eop->mmem, false);
+			break;
+		case BPF_OP_MSH:
+			compare_uint32_ret(op->msh, eop->msh, false);
+			break;
+		case BPF_OP_EXT:
+			compare_enum_ret(op->ext, eop->ext, false);
+			break;
+		case BPF_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_uint32_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_evm.c

@@ -0,0 +1,40 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_evm.h"
+#include <capstone/capstone.h>
+
+TestDetailEVM *test_detail_evm_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailEVM), 1);
+}
+
+void test_detail_evm_free(TestDetailEVM *detail)
+{
+	if (!detail) {
+		return;
+	}
+	cs_mem_free(detail);
+}
+
+TestDetailEVM *test_detail_evm_clone(const TestDetailEVM *detail)
+{
+	TestDetailEVM *clone = test_detail_evm_new();
+	clone->fee = detail->fee;
+	clone->pop = detail->pop;
+	clone->push = detail->push;
+	return clone;
+}
+
+bool test_expected_evm(csh *handle, const cs_evm *actual,
+		       const TestDetailEVM *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->fee, expected->fee, false);
+	compare_uint8_ret(actual->pop, expected->pop, false);
+	compare_uint8_ret(actual->push, expected->push, false);
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_hppa.c

@@ -0,0 +1,118 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "capstone/hppa.h"
+#include "test_compare.h"
+#include "test_detail_hppa.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailHPPA *test_detail_hppa_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailHPPA), 1);
+}
+
+void test_detail_hppa_free(TestDetailHPPA *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_hppa_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailHPPA *test_detail_hppa_clone(const TestDetailHPPA *detail)
+{
+	TestDetailHPPA *clone = test_detail_hppa_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailHPPAOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_hppa_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailHPPAOp *test_detail_hppa_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailHPPAOp), 1);
+}
+
+TestDetailHPPAOp *test_detail_hppa_op_clone(const TestDetailHPPAOp *op)
+{
+	TestDetailHPPAOp *clone = test_detail_hppa_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_space = op->mem_space ? strdup(op->mem_space) : NULL;
+	clone->mem_base_access =
+		op->mem_base_access ? strdup(op->mem_base_access) : NULL;
+
+	return clone;
+}
+
+void test_detail_hppa_op_free(TestDetailHPPAOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_base_access);
+	cs_mem_free(op->mem_space);
+	cs_mem_free(op);
+}
+
+bool test_expected_hppa(csh *handle, const cs_hppa *actual,
+			const TestDetailHPPA *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_hppa_op *op = &actual->operands[i];
+		TestDetailHPPAOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"hppa op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case HPPA_OP_REG:
+		case HPPA_OP_IDX_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case HPPA_OP_DISP:
+		case HPPA_OP_IMM:
+		case HPPA_OP_TARGET:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		case HPPA_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.space, eop->mem_space,
+					false);
+			compare_enum_ret(op->mem.base_access,
+					 eop->mem_base_access, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_loongarch.c

@@ -0,0 +1,114 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_loongarch.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailLoongArch *test_detail_loongarch_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailLoongArch), 1);
+}
+
+void test_detail_loongarch_free(TestDetailLoongArch *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_loongarch_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->format);
+	cs_mem_free(detail);
+}
+
+TestDetailLoongArch *
+test_detail_loongarch_clone(const TestDetailLoongArch *detail)
+{
+	TestDetailLoongArch *clone = test_detail_loongarch_new();
+
+	clone->format = detail->format ? strdup(detail->format) : NULL;
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailLoongArchOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_loongarch_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailLoongArchOp *test_detail_loongarch_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailLoongArchOp), 1);
+}
+
+TestDetailLoongArchOp *
+test_detail_loongarch_op_clone(const TestDetailLoongArchOp *op)
+{
+	TestDetailLoongArchOp *clone = test_detail_loongarch_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_disp = op->mem_disp;
+
+	return clone;
+}
+
+void test_detail_loongarch_op_free(TestDetailLoongArchOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op);
+}
+
+bool test_expected_loongarch(csh *handle, const cs_loongarch *actual,
+			     const TestDetailLoongArch *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	compare_enum_ret(actual->format, expected->format, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_loongarch_op *op = &actual->operands[i];
+		TestDetailLoongArchOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"loongarch op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case LOONGARCH_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case LOONGARCH_OP_IMM:
+			compare_uint64_ret(op->imm, eop->imm, false);
+			break;
+		case LOONGARCH_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+			compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_m680x.c

@@ -0,0 +1,215 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_m680x.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailM680xIdx *test_detail_m680x_idx_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailM680xIdx), 1);
+}
+
+TestDetailM680xIdx *test_detail_m680x_idx_clone(const TestDetailM680xIdx *idx)
+{
+	assert(idx);
+	TestDetailM680xIdx *clone = test_detail_m680x_idx_new();
+	clone->base_reg = idx->base_reg ? strdup(idx->base_reg) : NULL;
+	clone->offset_reg = idx->offset_reg ? strdup(idx->offset_reg) : NULL;
+	clone->flags = idx->flags_count > 0 ?
+			       cs_mem_calloc(sizeof(char *), idx->flags_count) :
+			       NULL;
+	clone->flags_count = idx->flags_count;
+	for (size_t i = 0; i < clone->flags_count; ++i) {
+		clone->flags[i] = idx->flags[i] ? strdup(idx->flags[i]) : NULL;
+	}
+	clone->offset = idx->offset;
+	clone->offset_addr = idx->offset_addr;
+	clone->offset_bits = idx->offset_bits;
+	clone->inc_dec = idx->inc_dec;
+	return clone;
+}
+
+void test_detail_m680x_idx_free(TestDetailM680xIdx *idx)
+{
+	if (!idx) {
+		return;
+	}
+	cs_mem_free(idx->base_reg);
+	cs_mem_free(idx->offset_reg);
+	for (size_t i = 0; i < idx->flags_count; ++i) {
+		cs_mem_free(idx->flags[i]);
+	}
+	cs_mem_free(idx->flags);
+	cs_mem_free(idx);
+}
+
+TestDetailM680x *test_detail_m680x_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailM680x), 1);
+}
+
+void test_detail_m680x_free(TestDetailM680x *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_m680x_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	for (size_t i = 0; i < detail->flags_count; ++i) {
+		cs_mem_free(detail->flags[i]);
+	}
+	cs_mem_free(detail->flags);
+	cs_mem_free(detail);
+}
+
+TestDetailM680x *test_detail_m680x_clone(const TestDetailM680x *detail)
+{
+	TestDetailM680x *clone = test_detail_m680x_new();
+
+	clone->flags_count = detail->flags_count;
+	if (detail->flags_count > 0) {
+		clone->flags =
+			cs_mem_calloc(sizeof(char *), detail->flags_count);
+	}
+	for (size_t i = 0; i < detail->flags_count; ++i) {
+		clone->flags[i] = detail->flags[i] ? strdup(detail->flags[i]) :
+						     NULL;
+	}
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailM680xOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_m680x_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailM680xOp *test_detail_m680x_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailM680xOp), 1);
+}
+
+TestDetailM680xOp *test_detail_m680x_op_clone(const TestDetailM680xOp *op)
+{
+	TestDetailM680xOp *clone = test_detail_m680x_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->idx = op->idx ? test_detail_m680x_idx_clone(op->idx) : NULL;
+	clone->imm = op->imm;
+	clone->rel_address = op->rel_address;
+	clone->rel_offset = op->rel_offset;
+	clone->ext_address = op->ext_address;
+	clone->ext_indirect = op->ext_indirect;
+	clone->direct_addr = op->direct_addr;
+	clone->direct_addr_set = op->direct_addr_set;
+	clone->const_val = op->const_val;
+	clone->size = op->size;
+
+	return clone;
+}
+
+void test_detail_m680x_op_free(TestDetailM680xOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	test_detail_m680x_idx_free(op->idx);
+	cs_mem_free(op);
+}
+
+bool test_expected_m680x(csh *handle, const cs_m680x *actual,
+			 const TestDetailM680x *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_m680x_op *op = &actual->operands[i];
+		TestDetailM680xOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		if (eop->size > 0) {
+			compare_uint8_ret(op->size, eop->size, false);
+		}
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"m680x op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case M680X_OP_REGISTER:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case M680X_OP_IMMEDIATE:
+			compare_int32_ret(op->imm, eop->imm, false);
+			break;
+		case M680X_OP_EXTENDED:
+			compare_uint16_ret(op->ext.address, eop->ext_address,
+					   false);
+			compare_tbool_ret(op->ext.indirect, eop->ext_indirect,
+					  false);
+			break;
+		case M680X_OP_DIRECT:
+			if (eop->direct_addr_set) {
+				compare_uint8_ret(op->direct_addr,
+						  eop->direct_addr, false);
+			} else {
+				assert(eop->direct_addr == 0);
+			}
+			break;
+		case M680X_OP_RELATIVE:
+			compare_uint16_ret(op->rel.address, eop->rel_address,
+					   false);
+			compare_int16_ret(op->rel.offset, eop->rel_offset,
+					  false);
+			break;
+		case M680X_OP_CONSTANT:
+			compare_uint8_ret(op->const_val, eop->const_val, false);
+			break;
+		case M680X_OP_INDEXED:
+			if (!eop->idx) {
+				break;
+			}
+			compare_reg_ret(*handle, op->idx.base_reg,
+					eop->idx->base_reg, false);
+			compare_reg_ret(*handle, op->idx.offset_reg,
+					eop->idx->offset_reg, false);
+			if (eop->idx->offset) {
+				compare_int16_ret(op->idx.offset,
+						  eop->idx->offset, false);
+			}
+			if (eop->idx->offset_addr) {
+				compare_uint16_ret(op->idx.offset_addr,
+						   eop->idx->offset_addr,
+						   false);
+			}
+			if (eop->idx->offset_bits) {
+				compare_uint8_ret(op->idx.offset_bits,
+						  eop->idx->offset_bits, false);
+			}
+			if (eop->idx->inc_dec) {
+				compare_int8_ret(op->idx.inc_dec,
+						 eop->idx->inc_dec, false);
+			}
+			compare_bit_flags_ret(op->idx.flags, eop->idx->flags,
+					      eop->idx->flags_count, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_m68k.c

@@ -0,0 +1,226 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "capstone/m68k.h"
+#include "test_compare.h"
+#include "test_detail_m68k.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailM68KOpMem *test_detail_m68k_op_mem_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailM68KOpMem), 1);
+}
+
+TestDetailM68KOpMem *test_detail_m68k_op_mem_clone(TestDetailM68KOpMem *mem)
+{
+	assert(mem);
+	TestDetailM68KOpMem *clone = test_detail_m68k_op_mem_new();
+
+	clone->base_reg = mem->base_reg ? strdup(mem->base_reg) : NULL;
+	clone->index_reg = mem->index_reg ? strdup(mem->index_reg) : NULL;
+	clone->in_base_reg = mem->in_base_reg ? strdup(mem->in_base_reg) : NULL;
+	clone->index_size = mem->index_size;
+	clone->disp = mem->disp;
+	clone->in_disp = mem->in_disp;
+	clone->out_disp = mem->out_disp;
+	clone->scale = mem->scale;
+	clone->bitfield = mem->bitfield;
+	clone->width = mem->width;
+	clone->offset = mem->offset;
+
+	return clone;
+}
+
+void test_detail_m68k_op_mem_free(TestDetailM68KOpMem *mem)
+{
+	if (!mem) {
+		return;
+	}
+	cs_mem_free(mem->base_reg);
+	cs_mem_free(mem->index_reg);
+	cs_mem_free(mem->in_base_reg);
+	cs_mem_free(mem);
+}
+
+TestDetailM68K *test_detail_m68k_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailM68K), 1);
+}
+
+void test_detail_m68k_free(TestDetailM68K *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_m68k_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->op_size_type);
+	cs_mem_free(detail->op_size_fpu);
+	cs_mem_free(detail->op_size_cpu);
+	cs_mem_free(detail);
+}
+
+TestDetailM68K *test_detail_m68k_clone(TestDetailM68K *detail)
+{
+	TestDetailM68K *clone = test_detail_m68k_new();
+	clone->op_size_type =
+		detail->op_size_type ? strdup(detail->op_size_type) : NULL;
+	clone->op_size_fpu = detail->op_size_fpu ? strdup(detail->op_size_fpu) :
+						   NULL;
+	clone->op_size_cpu = detail->op_size_cpu ? strdup(detail->op_size_cpu) :
+						   NULL;
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailM68KOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_m68k_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailM68KOp *test_detail_m68k_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailM68KOp), 1);
+}
+
+TestDetailM68KOp *test_detail_m68k_op_clone(TestDetailM68KOp *op)
+{
+	TestDetailM68KOp *clone = test_detail_m68k_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->reg_pair_0 = op->reg_pair_0 ? strdup(op->reg_pair_0) : NULL;
+	clone->reg_pair_1 = op->reg_pair_1 ? strdup(op->reg_pair_1) : NULL;
+	clone->address_mode = op->address_mode ? strdup(op->address_mode) :
+						 NULL;
+
+	clone->imm = op->imm;
+	clone->dimm = op->dimm;
+	clone->simm = op->simm;
+	clone->br_disp = op->br_disp;
+	clone->br_disp_size = op->br_disp_size;
+	clone->register_bits = op->register_bits;
+
+	clone->mem = op->mem ? test_detail_m68k_op_mem_clone(op->mem) : NULL;
+	return clone;
+}
+
+void test_detail_m68k_op_free(TestDetailM68KOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->reg_pair_0);
+	cs_mem_free(op->reg_pair_1);
+	cs_mem_free(op->address_mode);
+	test_detail_m68k_op_mem_free(op->mem);
+	cs_mem_free(op);
+}
+
+bool test_expected_m68k(csh *handle, cs_m68k *actual, TestDetailM68K *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	compare_enum_ret(actual->op_size.type, expected->op_size_type, false);
+	compare_enum_ret(actual->op_size.fpu_size, expected->op_size_fpu,
+			 false);
+	compare_enum_ret(actual->op_size.cpu_size, expected->op_size_cpu,
+			 false);
+
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		cs_m68k_op *op = &actual->operands[i];
+		TestDetailM68KOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->address_mode, eop->address_mode, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"M68K op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case M68K_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case M68K_OP_REG_PAIR:
+			compare_reg_ret(*handle, op->reg_pair.reg_0,
+					eop->reg_pair_0, false);
+			compare_reg_ret(*handle, op->reg_pair.reg_1,
+					eop->reg_pair_1, false);
+			break;
+		case M68K_OP_IMM:
+			compare_uint64_ret(op->imm, eop->imm, false);
+			break;
+		case M68K_OP_FP_SINGLE:
+			compare_fp_ret(op->simm, eop->simm, false);
+			break;
+		case M68K_OP_FP_DOUBLE:
+			compare_fp_ret(op->dimm, eop->dimm, false);
+			break;
+		case M68K_OP_REG_BITS:
+			compare_uint32_ret(op->register_bits,
+					   eop->register_bits, false);
+			break;
+		case M68K_OP_BR_DISP:
+			compare_int32_ret(op->br_disp.disp, eop->br_disp,
+					  false);
+			compare_uint8_ret(op->br_disp.disp_size,
+					  eop->br_disp_size, false);
+			break;
+		case M68K_OP_MEM:
+			if (!eop->mem) {
+				break;
+			}
+			compare_reg_ret(*handle, op->mem.base_reg,
+					eop->mem->base_reg, false);
+			compare_reg_ret(*handle, op->mem.index_reg,
+					eop->mem->index_reg, false);
+			compare_reg_ret(*handle, op->mem.in_base_reg,
+					eop->mem->in_base_reg, false);
+			compare_tbool_ret(op->mem.index_size,
+					  eop->mem->index_size, false);
+			if (eop->mem->in_disp) {
+				compare_uint32_ret(op->mem.in_disp,
+						   eop->mem->in_disp, false);
+			}
+			if (eop->mem->out_disp) {
+				compare_uint32_ret(op->mem.out_disp,
+						   eop->mem->out_disp, false);
+			}
+			if (eop->mem->disp) {
+				compare_int16_ret(op->mem.disp, eop->mem->disp,
+						  false);
+			}
+			if (eop->mem->scale) {
+				compare_uint8_ret(op->mem.scale,
+						  eop->mem->scale, false);
+			}
+			if (eop->mem->bitfield) {
+				compare_uint8_ret(op->mem.bitfield,
+						  eop->mem->bitfield, false);
+			}
+			if (eop->mem->width) {
+				compare_uint8_ret(op->mem.width,
+						  eop->mem->width, false);
+			}
+			if (eop->mem->offset) {
+				compare_uint8_ret(op->mem.offset,
+						  eop->mem->offset, false);
+			}
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_mips.c

@@ -0,0 +1,106 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_mips.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailMips *test_detail_mips_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailMips), 1);
+}
+
+void test_detail_mips_free(TestDetailMips *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_mips_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailMips *test_detail_mips_clone(const TestDetailMips *detail)
+{
+	TestDetailMips *clone = test_detail_mips_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailMipsOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_mips_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailMipsOp *test_detail_mips_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailMipsOp), 1);
+}
+
+TestDetailMipsOp *test_detail_mips_op_clone(const TestDetailMipsOp *op)
+{
+	TestDetailMipsOp *clone = test_detail_mips_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_disp = op->mem_disp;
+
+	return clone;
+}
+
+void test_detail_mips_op_free(TestDetailMipsOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op);
+}
+
+bool test_expected_mips(csh *handle, const cs_mips *actual,
+			const TestDetailMips *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_mips_op *op = &actual->operands[i];
+		TestDetailMipsOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr, "sh op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case MIPS_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case MIPS_OP_IMM:
+			compare_uint64_ret(op->imm, eop->imm, false);
+			break;
+		case MIPS_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_mos65xx.c

@@ -0,0 +1,105 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_mos65xx.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailMos65xx *test_detail_mos65xx_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailMos65xx), 1);
+}
+
+void test_detail_mos65xx_free(TestDetailMos65xx *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_mos65xx_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->am);
+	cs_mem_free(detail);
+}
+
+TestDetailMos65xx *test_detail_mos65xx_clone(const TestDetailMos65xx *detail)
+{
+	TestDetailMos65xx *clone = test_detail_mos65xx_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailMos65xxOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_mos65xx_op_clone(detail->operands[i]);
+	}
+	clone->am = detail->am ? strdup(detail->am) : NULL;
+	clone->modifies_flags = detail->modifies_flags;
+
+	return clone;
+}
+
+TestDetailMos65xxOp *test_detail_mos65xx_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailMos65xxOp), 1);
+}
+
+TestDetailMos65xxOp *test_detail_mos65xx_op_clone(const TestDetailMos65xxOp *op)
+{
+	TestDetailMos65xxOp *clone = test_detail_mos65xx_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem = op->mem;
+
+	return clone;
+}
+
+void test_detail_mos65xx_op_free(TestDetailMos65xxOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->reg);
+	cs_mem_free(op);
+}
+
+bool test_expected_mos65xx(csh *handle, const cs_mos65xx *actual,
+			   const TestDetailMos65xx *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	compare_enum_ret(actual->am, expected->am, false);
+	compare_tbool_ret(actual->modifies_flags, expected->modifies_flags,
+			  false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_mos65xx_op *op = &actual->operands[i];
+		TestDetailMos65xxOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr, "sh op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case MOS65XX_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case MOS65XX_OP_IMM:
+			compare_uint16_ret(op->imm, eop->imm, false);
+			break;
+		case MOS65XX_OP_MEM:
+			compare_uint16_ret(op->mem, eop->mem, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_ppc.c

@@ -0,0 +1,185 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_ppc.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailPPCBC *test_detail_ppc_bc_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailPPCBC), 1);
+}
+
+TestDetailPPCBC *test_detail_ppc_bc_clone(const TestDetailPPCBC *bc)
+{
+	assert(bc);
+	TestDetailPPCBC *clone = test_detail_ppc_bc_new();
+	clone->bh = bc->bh ? strdup(bc->bh) : NULL;
+	clone->crX = bc->crX ? strdup(bc->crX) : NULL;
+	clone->crX_bit = bc->crX_bit ? strdup(bc->crX_bit) : NULL;
+	clone->hint = bc->hint ? strdup(bc->hint) : NULL;
+	clone->pred_cr = bc->pred_cr ? strdup(bc->pred_cr) : NULL;
+	clone->pred_ctr = bc->pred_ctr ? strdup(bc->pred_ctr) : NULL;
+	clone->bi = bc->bi;
+	clone->bi_set = bc->bi_set;
+	clone->bo = bc->bo;
+	clone->bo_set = bc->bo_set;
+	return clone;
+}
+
+void test_detail_ppc_bc_free(TestDetailPPCBC *bc)
+{
+	if (!bc) {
+		return;
+	}
+	cs_mem_free(bc->bh);
+	cs_mem_free(bc->crX);
+	cs_mem_free(bc->crX_bit);
+	cs_mem_free(bc->hint);
+	cs_mem_free(bc->pred_cr);
+	cs_mem_free(bc->pred_ctr);
+	cs_mem_free(bc);
+}
+
+TestDetailPPC *test_detail_ppc_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailPPC), 1);
+}
+
+void test_detail_ppc_free(TestDetailPPC *detail)
+{
+	if (!detail) {
+		return;
+	}
+	test_detail_ppc_bc_free(detail->bc);
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_ppc_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->format);
+	cs_mem_free(detail);
+}
+
+TestDetailPPC *test_detail_ppc_clone(const TestDetailPPC *detail)
+{
+	TestDetailPPC *clone = test_detail_ppc_new();
+	clone->format = detail->format ? strdup(detail->format) : NULL;
+	clone->update_cr0 = detail->update_cr0;
+	clone->bc = detail->bc ? test_detail_ppc_bc_clone(detail->bc) : NULL;
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailPPCOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_ppc_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailPPCOp *test_detail_ppc_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailPPCOp), 1);
+}
+
+TestDetailPPCOp *test_detail_ppc_op_clone(const TestDetailPPCOp *op)
+{
+	TestDetailPPCOp *clone = test_detail_ppc_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_offset = op->mem_offset ? strdup(op->mem_offset) : NULL;
+	clone->mem_disp = op->mem_disp;
+
+	return clone;
+}
+
+void test_detail_ppc_op_free(TestDetailPPCOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_offset);
+	cs_mem_free(op);
+}
+
+bool test_expected_ppc(csh *handle, const cs_ppc *actual,
+		       const TestDetailPPC *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_enum_ret(actual->format, expected->format, false);
+	compare_tbool_ret(actual->update_cr0, expected->update_cr0, false);
+
+	if (expected->operands_count == 0) {
+		return true;
+	}
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_ppc_op *op = &actual->operands[i];
+		TestDetailPPCOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"arm op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case PPC_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case PPC_OP_IMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		case PPC_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.offset,
+					eop->mem_offset, false);
+			compare_int_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+
+		if (expected->bc) {
+			if (expected->bc->bi_set) {
+				compare_uint8_ret(actual->bc.bi,
+						  expected->bc->bi, false);
+			} else {
+				assert(expected->bc->bi == 0);
+			}
+			if (expected->bc->bo_set) {
+				compare_uint8_ret(actual->bc.bo,
+						  expected->bc->bo, false);
+			} else {
+				assert(expected->bc->bo == 0);
+			}
+			compare_enum_ret(actual->bc.bh, expected->bc->bh,
+					 false);
+			compare_reg_ret(*handle, actual->bc.crX,
+					expected->bc->crX, false);
+			compare_enum_ret(actual->bc.crX_bit,
+					 expected->bc->crX_bit, false);
+			compare_enum_ret(actual->bc.hint, expected->bc->hint,
+					 false);
+			compare_enum_ret(actual->bc.pred_cr,
+					 expected->bc->pred_cr, false);
+			compare_enum_ret(actual->bc.pred_ctr,
+					 expected->bc->pred_ctr, false);
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_riscv.c

@@ -0,0 +1,106 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_riscv.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailRISCV *test_detail_riscv_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailRISCV), 1);
+}
+
+void test_detail_riscv_free(TestDetailRISCV *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_riscv_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailRISCV *test_detail_riscv_clone(const TestDetailRISCV *detail)
+{
+	TestDetailRISCV *clone = test_detail_riscv_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailRISCVOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_riscv_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailRISCVOp *test_detail_riscv_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailRISCVOp), 1);
+}
+
+TestDetailRISCVOp *test_detail_riscv_op_clone(const TestDetailRISCVOp *op)
+{
+	TestDetailRISCVOp *clone = test_detail_riscv_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_disp = op->mem_disp;
+
+	return clone;
+}
+
+void test_detail_riscv_op_free(TestDetailRISCVOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op);
+}
+
+bool test_expected_riscv(csh *handle, const cs_riscv *actual,
+			 const TestDetailRISCV *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_riscv_op *op = &actual->operands[i];
+		TestDetailRISCVOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr, "sh op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case RISCV_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case RISCV_OP_IMM:
+			compare_uint64_ret(op->imm, eop->imm, false);
+			break;
+		case RISCV_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_sh.c

@@ -0,0 +1,107 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_sh.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailSH *test_detail_sh_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailSH), 1);
+}
+
+void test_detail_sh_free(TestDetailSH *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_sh_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailSH *test_detail_sh_clone(const TestDetailSH *detail)
+{
+	TestDetailSH *clone = test_detail_sh_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailSHOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_sh_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailSHOp *test_detail_sh_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailSHOp), 1);
+}
+
+TestDetailSHOp *test_detail_sh_op_clone(const TestDetailSHOp *op)
+{
+	TestDetailSHOp *clone = test_detail_sh_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_reg = op->mem_reg ? strdup(op->mem_reg) : NULL;
+	clone->mem_address = op->mem_address ? strdup(op->mem_address) : NULL;
+	clone->mem_disp = op->mem_disp;
+
+	return clone;
+}
+
+void test_detail_sh_op_free(TestDetailSHOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_reg);
+	cs_mem_free(op->mem_address);
+	cs_mem_free(op);
+}
+
+bool test_expected_sh(csh *handle, const cs_sh *actual,
+		      const TestDetailSH *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_sh_op *op = &actual->operands[i];
+		TestDetailSHOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr, "sh op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case SH_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case SH_OP_IMM:
+			compare_uint64_ret(op->imm, eop->imm, false);
+			break;
+		case SH_OP_MEM:
+			compare_reg_ret(*handle, op->mem.reg, eop->mem_reg,
+					false);
+			compare_reg_ret(*handle, op->mem.address,
+					eop->mem_address, false);
+			compare_int_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_sparc.c

@@ -0,0 +1,141 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_sparc.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailSparc *test_detail_sparc_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailSparc), 1);
+}
+
+void test_detail_sparc_free(TestDetailSparc *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_sparc_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->cc);
+	cs_mem_free(detail->cc_field);
+	cs_mem_free(detail->hint);
+	cs_mem_free(detail);
+}
+
+TestDetailSparc *test_detail_sparc_clone(const TestDetailSparc *detail)
+{
+	TestDetailSparc *clone = test_detail_sparc_new();
+
+	clone->operands_count = detail->operands_count;
+	clone->cc = detail->cc ? strdup(detail->cc) : NULL;
+	clone->cc_field = detail->cc_field ? strdup(detail->cc_field) : NULL;
+	clone->hint = detail->hint ? strdup(detail->hint) : NULL;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailSparcOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_sparc_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailSparcOp *test_detail_sparc_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailSparcOp), 1);
+}
+
+TestDetailSparcOp *test_detail_sparc_op_clone(const TestDetailSparcOp *op)
+{
+	TestDetailSparcOp *clone = test_detail_sparc_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_index = op->mem_index ? strdup(op->mem_index) : NULL;
+	clone->mem_disp = op->mem_disp;
+	clone->asi = op->asi ? strdup(op->asi) : NULL;
+	clone->membar_tag = op->membar_tag ? strdup(op->membar_tag) : NULL;
+
+	return clone;
+}
+
+void test_detail_sparc_op_free(TestDetailSparcOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_index);
+	cs_mem_free(op->asi);
+	cs_mem_free(op->membar_tag);
+	cs_mem_free(op);
+}
+
+bool test_expected_sparc(csh *handle, const cs_sparc *actual,
+			 const TestDetailSparc *expected)
+{
+	assert(handle && actual && expected);
+
+	if (expected->cc) {
+		compare_enum_ret(actual->cc, expected->cc, false);
+	}
+	if (expected->cc_field) {
+		compare_enum_ret(actual->cc_field, expected->cc_field, false);
+	}
+	if (expected->hint) {
+		compare_enum_ret(actual->hint, expected->hint, false);
+	}
+
+	if (expected->operands_count == 0) {
+		return true;
+	}
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+
+	for (size_t i = 0; i < expected->operands_count; ++i) {
+		const cs_sparc_op *op = &actual->operands[i];
+		TestDetailSparcOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"arm op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case SPARC_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case SPARC_OP_IMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		case SPARC_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+			compare_int32_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		case SPARC_OP_ASI:
+			compare_enum_ret(op->asi, eop->asi, false);
+			break;
+		case SPARC_OP_MEMBAR_TAG:
+			compare_enum_ret(op->membar_tag, eop->membar_tag, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_systemz.c

@@ -0,0 +1,148 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_systemz.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailSystemZ *test_detail_systemz_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailSystemZ), 1);
+}
+
+void test_detail_systemz_free(TestDetailSystemZ *detail)
+{
+	if (!detail) {
+		return;
+	}
+	cs_mem_free(detail->format);
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_systemz_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailSystemZ *test_detail_systemz_clone(const TestDetailSystemZ *detail)
+{
+	TestDetailSystemZ *clone = test_detail_systemz_new();
+
+	clone->format = detail->format ? strdup(detail->format) : NULL;
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailSystemZOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_systemz_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailSystemZOp *test_detail_systemz_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailSystemZOp), 1);
+}
+
+TestDetailSystemZOp *test_detail_systemz_op_clone(const TestDetailSystemZOp *op)
+{
+	TestDetailSystemZOp *clone = test_detail_systemz_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->imm_width = op->imm_width;
+	clone->mem_am = op->mem_am ? strdup(op->mem_am) : NULL;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_index = op->mem_index ? strdup(op->mem_index) : NULL;
+	clone->mem_disp = op->mem_disp;
+	clone->mem_length = op->mem_length;
+
+	return clone;
+}
+
+void test_detail_systemz_op_free(TestDetailSystemZOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_am);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_index);
+	cs_mem_free(op);
+}
+
+bool test_expected_systemz(csh *handle, const cs_systemz *actual,
+			   const TestDetailSystemZ *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_enum_ret(actual->format, expected->format, false);
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_systemz_op *op = &actual->operands[i];
+		TestDetailSystemZOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"arm op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case SYSTEMZ_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case SYSTEMZ_OP_IMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			compare_uint8_ret(op->imm_width, eop->imm_width, false);
+			break;
+		case SYSTEMZ_OP_MEM:
+			compare_enum_ret(op->mem.am, eop->mem_am, false);
+			switch(op->mem.am) {
+			default:
+				assert(0 && "Address mode not handled\n");
+				break;
+			case SYSTEMZ_AM_BD:
+				compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+				compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+				break;
+			case SYSTEMZ_AM_BDX:
+			case SYSTEMZ_AM_BDV:
+				compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+				compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+				compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+				break;
+			case SYSTEMZ_AM_BDL:
+				compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+				compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+				compare_uint64_ret(op->mem.length, eop->mem_length,
+					   false);
+				break;
+			case SYSTEMZ_AM_BDR:
+				compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+				compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+				compare_uint64_ret(op->mem.length, eop->mem_length,
+					   false);
+				break;
+			}
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_tms320c64x.c

@@ -0,0 +1,179 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "capstone/tms320c64x.h"
+#include "test_compare.h"
+#include "test_detail_tms320c64x.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailTMS320c64x *test_detail_tms320c64x_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailTMS320c64x), 1);
+}
+
+void test_detail_tms320c64x_free(TestDetailTMS320c64x *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_tms320c64x_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->cond_reg);
+	cs_mem_free(detail->funit_unit);
+	cs_mem_free(detail);
+}
+
+TestDetailTMS320c64x *test_detail_tms320c64x_clone(TestDetailTMS320c64x *detail)
+{
+	TestDetailTMS320c64x *clone = test_detail_tms320c64x_new();
+	clone->cond_reg = detail->cond_reg ? strdup(detail->cond_reg) : NULL;
+	clone->cond_zero = detail->cond_zero;
+	clone->funit_unit = detail->funit_unit ? strdup(detail->funit_unit) :
+						 NULL;
+	clone->funit_side = detail->funit_side;
+	clone->funit_side_set = detail->funit_side_set;
+	clone->funit_crosspath = detail->funit_crosspath;
+	clone->funit_crosspath_set = detail->funit_crosspath_set;
+
+	clone->parallel = detail->parallel;
+	clone->parallel_set = detail->parallel_set;
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands =
+			cs_mem_calloc(sizeof(TestDetailTMS320c64xOp *),
+				      detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_tms320c64x_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailTMS320c64xOp *test_detail_tms320c64x_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailTMS320c64xOp), 1);
+}
+
+TestDetailTMS320c64xOp *
+test_detail_tms320c64x_op_clone(TestDetailTMS320c64xOp *op)
+{
+	TestDetailTMS320c64xOp *clone = test_detail_tms320c64x_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->reg_pair_0 = op->reg_pair_0 ? strdup(op->reg_pair_0) : NULL;
+	clone->reg_pair_1 = op->reg_pair_1 ? strdup(op->reg_pair_1) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_scaled = op->mem_scaled;
+	clone->mem_disptype = op->mem_disptype ? strdup(op->mem_disptype) :
+						 NULL;
+	clone->mem_direction = op->mem_direction ? strdup(op->mem_direction) :
+						   NULL;
+	clone->mem_modify = op->mem_modify ? strdup(op->mem_modify) : NULL;
+	clone->mem_disp_const = op->mem_disp_const;
+	clone->mem_disp_reg = op->mem_disp_reg ? strdup(op->mem_disp_reg) :
+						 NULL;
+	clone->mem_unit = op->mem_unit;
+
+	return clone;
+}
+
+void test_detail_tms320c64x_op_free(TestDetailTMS320c64xOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_disp_reg);
+	cs_mem_free(op->mem_disptype);
+	cs_mem_free(op->mem_direction);
+	cs_mem_free(op->mem_modify);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->reg_pair_0);
+	cs_mem_free(op->reg_pair_1);
+	cs_mem_free(op);
+}
+
+bool test_expected_tms320c64x(csh *handle, cs_tms320c64x *actual,
+			      TestDetailTMS320c64x *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	compare_reg_ret(*handle, actual->condition.reg, expected->cond_reg,
+			false);
+	compare_tbool_ret(actual->condition.zero, expected->cond_zero, false);
+	compare_enum_ret(actual->funit.unit, expected->funit_unit, false);
+	if (expected->funit_side_set) {
+		compare_uint8_ret(actual->funit.side, expected->funit_side,
+				  false);
+	} else {
+		assert(expected->funit_side == 0);
+	}
+	if (expected->funit_crosspath_set) {
+		compare_uint8_ret(actual->funit.crosspath,
+				  expected->funit_crosspath, false);
+	} else {
+		assert(expected->funit_crosspath == 0);
+	}
+	if (expected->parallel_set) {
+		compare_uint8_ret(actual->parallel, expected->parallel, false);
+	} else {
+		assert(expected->parallel == 0);
+	}
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		cs_tms320c64x_op *op = &actual->operands[i];
+		TestDetailTMS320c64xOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"tms320c64x op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case TMS320C64X_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case TMS320C64X_OP_REGPAIR:
+			compare_reg_ret(*handle, op->reg + 1, eop->reg_pair_0,
+					false);
+			compare_reg_ret(*handle, op->reg, eop->reg_pair_1,
+					false);
+			break;
+		case TMS320C64X_OP_IMM:
+			compare_int32_ret(op->imm, eop->imm, false);
+			break;
+		case TMS320C64X_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_enum_ret(op->mem.direction, eop->mem_direction,
+					 false);
+			compare_tbool_ret(op->mem.scaled, eop->mem_scaled,
+					  false);
+			compare_enum_ret(op->mem.disptype, eop->mem_disptype,
+					 false);
+			if (op->mem.disptype == TMS320C64X_MEM_DISP_REGISTER) {
+				compare_reg_ret(*handle, op->mem.disp,
+						eop->mem_disp_reg, false);
+			} else {
+				compare_uint_ret(op->mem.disp,
+						 eop->mem_disp_const, false);
+			}
+			compare_enum_ret(op->mem.modify, eop->mem_modify,
+					 false);
+			compare_uint_ret(op->mem.unit, eop->mem_unit, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_tricore.c

@@ -0,0 +1,109 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_tricore.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailTriCore *test_detail_tricore_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailTriCore), 1);
+}
+
+void test_detail_tricore_free(TestDetailTriCore *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_tricore_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailTriCore *test_detail_tricore_clone(const TestDetailTriCore *detail)
+{
+	TestDetailTriCore *clone = test_detail_tricore_new();
+	clone->update_flags = detail->update_flags;
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailTriCoreOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_tricore_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailTriCoreOp *test_detail_tricore_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailTriCoreOp), 1);
+}
+
+TestDetailTriCoreOp *test_detail_tricore_op_clone(const TestDetailTriCoreOp *op)
+{
+	TestDetailTriCoreOp *clone = test_detail_tricore_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_disp = op->mem_disp;
+
+	return clone;
+}
+
+void test_detail_tricore_op_free(TestDetailTriCoreOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op);
+}
+
+bool test_expected_tricore(csh *handle, const cs_tricore *actual,
+			   const TestDetailTriCore *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	compare_tbool_ret(actual->update_flags, expected->update_flags, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_tricore_op *op = &actual->operands[i];
+		TestDetailTriCoreOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"tricore op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case TRICORE_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case TRICORE_OP_IMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		case TRICORE_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_wasm.c

@@ -0,0 +1,128 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_wasm.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailWASM *test_detail_wasm_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailWASM), 1);
+}
+
+void test_detail_wasm_free(TestDetailWASM *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_wasm_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailWASM *test_detail_wasm_clone(const TestDetailWASM *detail)
+{
+	TestDetailWASM *clone = test_detail_wasm_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailWASMOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_wasm_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailWASMOp *test_detail_wasm_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailWASMOp), 1);
+}
+
+TestDetailWASMOp *test_detail_wasm_op_clone(const TestDetailWASMOp *op)
+{
+	TestDetailWASMOp *clone = test_detail_wasm_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->size = op->size;
+	clone->int7 = op->int7;
+	clone->varuint32 = op->varuint32;
+	clone->varuint64 = op->varuint64;
+	clone->uint32 = op->uint32;
+	clone->uint64 = op->uint64;
+	clone->immediate_0 = op->immediate_0;
+	clone->immediate_1 = op->immediate_1;
+	clone->brt_length = op->brt_length;
+	clone->brt_address = op->brt_address;
+	clone->brt_default_target = op->brt_default_target;
+	return clone;
+}
+
+void test_detail_wasm_op_free(TestDetailWASMOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op);
+}
+
+bool test_expected_wasm(csh *handle, const cs_wasm *actual,
+			const TestDetailWASM *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_wasm_op *op = &actual->operands[i];
+		TestDetailWASMOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"WASM op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case WASM_OP_INT7:
+			compare_int8_ret(op->int7, eop->int7, false);
+			break;
+		case WASM_OP_VARUINT32:
+			compare_uint32_ret(op->varuint32, eop->varuint32,
+					   false);
+			break;
+		case WASM_OP_VARUINT64:
+			compare_uint64_ret(op->varuint64, eop->varuint64,
+					   false);
+			break;
+		case WASM_OP_UINT32:
+			compare_uint32_ret(op->uint32, eop->uint32, false);
+			break;
+		case WASM_OP_UINT64:
+			compare_uint64_ret(op->uint64, eop->uint64, false);
+			break;
+		case WASM_OP_IMM:
+			compare_uint32_ret(op->immediate[0], eop->immediate_0,
+					   false);
+			compare_uint32_ret(op->immediate[1], eop->immediate_1,
+					   false);
+			break;
+		case WASM_OP_BRTABLE:
+			compare_uint32_ret(op->brtable.length, eop->brt_length,
+					   false);
+			compare_uint32_ret(op->brtable.default_target,
+					   eop->brt_default_target, false);
+			compare_uint64_ret(op->brtable.address,
+					   eop->brt_address, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_x86.c

@@ -0,0 +1,264 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_x86.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailX86 *test_detail_x86_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailX86), 1);
+}
+
+void test_detail_x86_free(TestDetailX86 *detail)
+{
+	if (!detail) {
+		return;
+	}
+	if (detail->prefix[0]) {
+		for (size_t i = 0; i < ARR_SIZE(detail->prefix); ++i) {
+			cs_mem_free(detail->prefix[i]);
+		}
+	}
+	for (size_t i = 0; i < detail->eflags_count; ++i) {
+		cs_mem_free(detail->eflags[i]);
+	}
+	cs_mem_free(detail->eflags);
+	for (size_t i = 0; i < detail->fpu_flags_count; ++i) {
+		cs_mem_free(detail->fpu_flags[i]);
+	}
+	cs_mem_free(detail->fpu_flags);
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_x86_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+
+	cs_mem_free(detail->sib_index);
+	cs_mem_free(detail->sib_base);
+	cs_mem_free(detail->xop_cc);
+	cs_mem_free(detail->sse_cc);
+	cs_mem_free(detail->avx_cc);
+	cs_mem_free(detail->avx_rm);
+	cs_mem_free(detail);
+}
+
+TestDetailX86 *test_detail_x86_clone(TestDetailX86 *detail)
+{
+	TestDetailX86 *clone = test_detail_x86_new();
+	clone->sib_index = detail->sib_index ? strdup(detail->sib_index) : NULL;
+	clone->sib_base = detail->sib_base ? strdup(detail->sib_base) : NULL;
+	clone->xop_cc = detail->xop_cc ? strdup(detail->xop_cc) : NULL;
+	clone->sse_cc = detail->sse_cc ? strdup(detail->sse_cc) : NULL;
+	clone->avx_cc = detail->avx_cc ? strdup(detail->avx_cc) : NULL;
+	clone->avx_rm = detail->avx_rm ? strdup(detail->avx_rm) : NULL;
+
+	if (detail->prefix[0]) {
+		for (size_t i = 0; i < ARR_SIZE(clone->prefix); ++i) {
+			clone->prefix[i] = strdup(detail->prefix[i]);
+		}
+	}
+	memcpy(clone->opcode, detail->opcode, sizeof(clone->opcode));
+
+	clone->rex = detail->rex;
+	clone->addr_size = detail->addr_size;
+	clone->modrm = detail->modrm;
+	clone->sib = detail->sib;
+	clone->disp = detail->disp;
+	clone->sib_scale = detail->sib_scale;
+	clone->avx_sae = detail->avx_sae;
+
+	clone->enc_modrm_offset = detail->enc_modrm_offset;
+	clone->enc_disp_offset = detail->enc_disp_offset;
+	clone->enc_disp_size = detail->enc_disp_size;
+	clone->enc_imm_offset = detail->enc_imm_offset;
+	clone->enc_imm_size = detail->enc_imm_size;
+
+	clone->eflags_count = detail->eflags_count;
+	clone->eflags = detail->eflags ? cs_mem_calloc(sizeof(char *),
+						       detail->eflags_count) :
+					 NULL;
+	for (size_t i = 0; clone->eflags && i < detail->eflags_count; ++i) {
+		clone->eflags[i] =
+			detail->eflags[i] ? strdup(detail->eflags[i]) : NULL;
+	}
+
+	clone->fpu_flags_count = detail->fpu_flags_count;
+	clone->fpu_flags =
+		detail->fpu_flags ?
+			cs_mem_calloc(sizeof(char *), detail->fpu_flags_count) :
+			NULL;
+	for (size_t i = 0; clone->fpu_flags && i < detail->fpu_flags_count; ++i) {
+		clone->fpu_flags[i] = detail->fpu_flags[i] ?
+					      strdup(detail->fpu_flags[i]) :
+					      NULL;
+	}
+
+	clone->operands_count = detail->operands_count;
+	clone->operands = detail->operands_count > 0 ?
+				  cs_mem_calloc(sizeof(TestDetailX86Op *),
+						detail->operands_count) :
+				  NULL;
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_x86_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailX86Op *test_detail_x86_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailX86Op), 1);
+}
+
+TestDetailX86Op *test_detail_x86_op_clone(TestDetailX86Op *op)
+{
+	TestDetailX86Op *clone = test_detail_x86_op_new();
+
+	clone->size = op->size;
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_segment = op->mem_segment ? strdup(op->mem_segment) : NULL;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_index = op->mem_index ? strdup(op->mem_index) : NULL;
+	clone->mem_scale = op->mem_scale;
+	clone->mem_disp = op->mem_disp;
+	clone->avx_bcast = op->avx_bcast ? strdup(op->avx_bcast) : NULL;
+	clone->avx_zero_opmask = op->avx_zero_opmask;
+
+	return clone;
+}
+
+void test_detail_x86_op_free(TestDetailX86Op *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_segment);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_index);
+	cs_mem_free(op->avx_bcast);
+	cs_mem_free(op);
+}
+
+bool test_expected_x86(csh *handle, cs_x86 *actual, TestDetailX86 *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_reg_ret(*handle, actual->sib_index, expected->sib_index, false);
+	compare_reg_ret(*handle, actual->sib_base, expected->sib_base, false);
+
+	compare_enum_ret(actual->xop_cc, expected->xop_cc, false);
+	compare_enum_ret(actual->sse_cc, expected->sse_cc, false);
+	compare_enum_ret(actual->avx_cc, expected->avx_cc, false);
+	compare_enum_ret(actual->avx_rm, expected->avx_rm, false);
+
+	if (expected->rex) {
+		compare_uint8_ret(actual->rex, expected->rex, false);
+	}
+	if (expected->addr_size) {
+		compare_uint8_ret(actual->addr_size, expected->addr_size, false);
+	}
+	if (expected->modrm) {
+		compare_uint8_ret(actual->modrm, expected->modrm, false);
+	}
+	if (expected->sib) {
+		compare_uint8_ret(actual->sib, expected->sib, false);
+	}
+	if (expected->disp) {
+		compare_int64_ret(actual->disp, expected->disp, false);
+	}
+	if (expected->sib_scale) {
+		compare_int8_ret(actual->sib_scale, expected->sib_scale, false);
+	}
+	compare_tbool_ret(actual->avx_sae, expected->avx_sae, false);
+
+	for (size_t i = 0; i < ARR_SIZE(actual->prefix); ++i) {
+		compare_enum_ret(actual->prefix[i], expected->prefix[i],
+				  false);
+	}
+	for (size_t i = 0; i < ARR_SIZE(actual->opcode); ++i) {
+		if (expected->opcode[i] != 0) {
+			compare_uint8_ret(actual->opcode[i], expected->opcode[i],
+					  false);
+		}
+	}
+
+	compare_bit_flags_64_ret(actual->eflags, expected->eflags,
+				 expected->eflags_count, false);
+	compare_bit_flags_64_ret(actual->fpu_flags, expected->fpu_flags,
+				 expected->fpu_flags_count, false);
+
+	if (expected->enc_modrm_offset) {
+		compare_uint8_ret(actual->encoding.modrm_offset,
+				  expected->enc_modrm_offset, false);
+	}
+	if (expected->enc_disp_offset) {
+		compare_uint8_ret(actual->encoding.disp_offset,
+				  expected->enc_disp_offset, false);
+	}
+	if (expected->enc_disp_size) {
+		compare_uint8_ret(actual->encoding.disp_size,
+				  expected->enc_disp_size, false);
+	}
+	if (expected->enc_imm_offset) {
+		compare_uint8_ret(actual->encoding.imm_offset,
+				  expected->enc_imm_offset, false);
+	}
+	if (expected->enc_imm_size) {
+		compare_uint8_ret(actual->encoding.imm_size,
+				  expected->enc_imm_size, false);
+	}
+
+	if (expected->operands_count == 0) {
+		return true;
+	}
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		cs_x86_op *op = &actual->operands[i];
+		TestDetailX86Op *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		compare_enum_ret(op->avx_bcast, eop->avx_bcast, false);
+		compare_tbool_ret(op->avx_zero_opmask, eop->avx_zero_opmask,
+				  false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"arm op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case X86_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case X86_OP_IMM:
+			compare_int64_ret(op->imm, eop->imm, false);
+			break;
+		case X86_OP_MEM:
+			compare_reg_ret(*handle, op->mem.segment,
+					eop->mem_segment, false);
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+			if (eop->mem_disp) {
+				compare_int64_ret(op->mem.disp, eop->mem_disp, false);
+			}
+			if (eop->mem_scale) {
+				compare_int_ret(op->mem.scale, eop->mem_scale,
+						false);
+			}
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_xcore.c

@@ -0,0 +1,113 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include "test_detail_xcore.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+
+TestDetailXCore *test_detail_xcore_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailXCore), 1);
+}
+
+void test_detail_xcore_free(TestDetailXCore *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_xcore_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail);
+}
+
+TestDetailXCore *test_detail_xcore_clone(const TestDetailXCore *detail)
+{
+	TestDetailXCore *clone = test_detail_xcore_new();
+
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailXCoreOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_xcore_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailXCoreOp *test_detail_xcore_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailXCoreOp), 1);
+}
+
+TestDetailXCoreOp *test_detail_xcore_op_clone(const TestDetailXCoreOp *op)
+{
+	TestDetailXCoreOp *clone = test_detail_xcore_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_index = op->mem_index ? strdup(op->mem_index) : NULL;
+	clone->mem_disp = op->mem_disp;
+	clone->mem_direct = op->mem_direct;
+
+	return clone;
+}
+
+void test_detail_xcore_op_free(TestDetailXCoreOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op->mem_index);
+	cs_mem_free(op);
+}
+
+bool test_expected_xcore(csh *handle, const cs_xcore *actual,
+			 const TestDetailXCore *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_xcore_op *op = &actual->operands[i];
+		TestDetailXCoreOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"arm op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case XCORE_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case XCORE_OP_IMM:
+			compare_int32_ret(op->imm, eop->imm, false);
+			break;
+		case XCORE_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_reg_ret(*handle, op->mem.index, eop->mem_index,
+					false);
+			compare_int_ret(op->mem.disp, eop->mem_disp, false);
+			if (eop->mem_direct) {
+				compare_int_ret(op->mem.direct, eop->mem_direct,
+						false);
+			}
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_detail_xtensa.c

@@ -0,0 +1,111 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// Copyright © 2024 Billow <billow.fun@gmail.com>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_compare.h"
+#include <capstone/capstone.h>
+#include <stdio.h>
+#include <string.h>
+#include <test_detail_xtensa.h>
+
+TestDetailXtensa *test_detail_xtensa_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailXtensa), 1);
+}
+
+void test_detail_xtensa_free(TestDetailXtensa *detail)
+{
+	if (!detail) {
+		return;
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		test_detail_xtensa_op_free(detail->operands[i]);
+	}
+	cs_mem_free(detail->operands);
+	cs_mem_free(detail->format);
+	cs_mem_free(detail);
+}
+
+TestDetailXtensa *test_detail_xtensa_clone(const TestDetailXtensa *detail)
+{
+	TestDetailXtensa *clone = test_detail_xtensa_new();
+	clone->format = detail->format ? strdup(detail->format) : NULL;
+	clone->operands_count = detail->operands_count;
+	if (detail->operands_count > 0) {
+		clone->operands = cs_mem_calloc(sizeof(TestDetailXtensaOp *),
+						detail->operands_count);
+	}
+	for (size_t i = 0; i < detail->operands_count; ++i) {
+		clone->operands[i] =
+			test_detail_xtensa_op_clone(detail->operands[i]);
+	}
+
+	return clone;
+}
+
+TestDetailXtensaOp *test_detail_xtensa_op_new()
+{
+	return cs_mem_calloc(sizeof(TestDetailXtensaOp), 1);
+}
+
+TestDetailXtensaOp *test_detail_xtensa_op_clone(const TestDetailXtensaOp *op)
+{
+	TestDetailXtensaOp *clone = test_detail_xtensa_op_new();
+
+	clone->type = op->type ? strdup(op->type) : NULL;
+	clone->access = op->access ? strdup(op->access) : NULL;
+	clone->reg = op->reg ? strdup(op->reg) : NULL;
+	clone->imm = op->imm;
+	clone->mem_base = op->mem_base ? strdup(op->mem_base) : NULL;
+	clone->mem_disp = op->mem_disp;
+
+	return clone;
+}
+
+void test_detail_xtensa_op_free(TestDetailXtensaOp *op)
+{
+	if (!op) {
+		return;
+	}
+	cs_mem_free(op->type);
+	cs_mem_free(op->access);
+	cs_mem_free(op->reg);
+	cs_mem_free(op->mem_base);
+	cs_mem_free(op);
+}
+
+bool test_expected_xtensa(csh *handle, const cs_xtensa *actual,
+			  const TestDetailXtensa *expected)
+{
+	assert(handle && actual && expected);
+
+	compare_enum_ret(actual->format, expected->format, false);
+	compare_uint8_ret(actual->op_count, expected->operands_count, false);
+	for (size_t i = 0; i < actual->op_count; ++i) {
+		const cs_xtensa_op *op = &actual->operands[i];
+		TestDetailXtensaOp *eop = expected->operands[i];
+		compare_enum_ret(op->type, eop->type, false);
+		compare_enum_ret(op->access, eop->access, false);
+		switch (op->type) {
+		default:
+			fprintf(stderr,
+				"xtensa op type %" PRId32 " not handled.\n",
+				op->type);
+			return false;
+		case XTENSA_OP_REG:
+			compare_reg_ret(*handle, op->reg, eop->reg, false);
+			break;
+		case XTENSA_OP_L32R:
+		case XTENSA_OP_IMM:
+			compare_int32_ret(op->imm, eop->imm, false);
+			break;
+		case XTENSA_OP_MEM:
+			compare_reg_ret(*handle, op->mem.base, eop->mem_base,
+					false);
+			compare_int32_ret(op->mem.disp, eop->mem_disp, false);
+			break;
+		}
+	}
+
+	return true;
+}

external/capstone/suite/cstest/src/test_run.c

@@ -0,0 +1,330 @@
+// Copyright © 2024 Rot127 <unisono@quyllur.org>
+// SPDX-License-Identifier: BSD-3
+
+#include "test_run.h"
+#include "test_case.h"
+#include "test_mapping.h"
+#include "../../../utils.h"
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include "cmocka.h"
+#include <capstone/capstone.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+static TestRunResult get_test_run_result(TestRunStats *stats)
+{
+	if (stats->tc_total !=
+	    stats->successful + stats->failed + stats->skipped) {
+		fprintf(stderr,
+			"[!] Inconsistent statistics: total != successful + failed + skipped\n");
+		stats->errors++;
+		return TEST_RUN_ERROR;
+	}
+
+	if (stats->errors != 0) {
+		return TEST_RUN_ERROR;
+	} else if (stats->failed != 0) {
+		return TEST_RUN_FAILURE;
+	}
+	return TEST_RUN_SUCCESS;
+}
+
+/// Extract all test cases from the given test files.
+static TestFile **parse_test_files(char **tf_paths, uint32_t path_count,
+				   TestRunStats *stats)
+{
+	TestFile **files = NULL;
+	stats->tc_total = 0;
+
+	for (size_t i = 0; i < path_count; ++i) {
+		TestFile *test_file_data = NULL;
+		cyaml_err_t err = cyaml_load_file(
+			tf_paths[i], &cyaml_config, &test_file_schema,
+			(cyaml_data_t **)&test_file_data, NULL);
+
+		if (err != CYAML_OK || !test_file_data) {
+			fprintf(stderr, "[!] Failed to parse test file '%s'\n",
+				tf_paths[i]);
+			fprintf(stderr, "[!] Error: '%s'\n",
+				!test_file_data && err == CYAML_OK ?
+					"Empty file" :
+					cyaml_strerror(err));
+			stats->invalid_files++;
+			stats->errors++;
+			continue;
+		}
+
+		size_t k = stats->valid_test_files++;
+		// Copy all test cases of a test file
+		files = cs_mem_realloc(files, sizeof(TestFile *) *
+						      stats->valid_test_files);
+
+		files[k] = test_file_clone(test_file_data);
+		assert(files[k]);
+		stats->tc_total += files[k]->test_cases_count;
+		files[k]->filename = strrchr(tf_paths[i], '/') ?
+					     strdup(strrchr(tf_paths[i], '/')) :
+					     strdup(tf_paths[i]);
+
+		err = cyaml_free(&cyaml_config, &test_file_schema,
+				 test_file_data, 0);
+		if (err != CYAML_OK) {
+			fprintf(stderr, "[!] Error: '%s'\n",
+				cyaml_strerror(err));
+			stats->errors++;
+			continue;
+		}
+	}
+
+	return files;
+}
+
+/// Parses the @input and saves the results in the other arguments.
+static bool parse_input_options(const TestInput *input, cs_arch *arch,
+				cs_mode *mode, cs_opt *opt_arr,
+				size_t opt_arr_size, size_t *opt_set)
+{
+	assert(input && arch && mode && opt_arr);
+	bool arch_found = false;
+	const char *opt_str = input->arch;
+
+	int val = enum_map_bin_search(test_arch_map, ARR_SIZE(test_arch_map),
+				      opt_str, &arch_found);
+	if (arch_found) {
+		*arch = val;
+	} else {
+		fprintf(stderr,
+			"[!] '%s' is not mapped to a capstone architecture.\n",
+			input->arch);
+		return false;
+	}
+
+	*mode = 0;
+	size_t opt_idx = 0;
+	char **options = input->options;
+	for (size_t i = 0; i < input->options_count; ++i) {
+		bool opt_found = false;
+		opt_str = options[i];
+		val = enum_map_bin_search(test_mode_map,
+						   ARR_SIZE(test_mode_map),
+						   opt_str, &opt_found);
+
+		if (opt_found) {
+			*mode |= val;
+			continue;
+		}
+
+		// Might be an option descriptor
+		for (size_t k = 0; k < ARR_SIZE(test_option_map); k++) {
+			if (strings_match(opt_str, test_option_map[k].str)) {
+				if (opt_idx >= opt_arr_size) {
+					fprintf(stderr,
+						"Too many options given in: '%s'. Maximum is: %" PRId64
+						"\n",
+						opt_str,
+						(uint64_t)opt_arr_size);
+					return false;
+				}
+				opt_arr[opt_idx++] = test_option_map[k].opt;
+				opt_found = true;
+				break;
+			}
+		}
+		if (!opt_found) {
+			fprintf(stderr, "[!] Option: '%s' not used\n", opt_str);
+		}
+	}
+	*opt_set = opt_idx;
+	return true;
+}
+
+/// Parses the options for cs_open/cs_option and initializes the handle.
+/// Returns true for success and false otherwise.
+static bool open_cs_handle(UnitTestState *ustate)
+{
+	cs_arch arch = 0;
+	cs_mode mode = 0;
+	cs_opt options[8] = { 0 };
+	size_t options_set = 0;
+
+	if (!parse_input_options(ustate->tcase->input, &arch, &mode, options, 8,
+				 &options_set)) {
+		char *tc_str = test_input_stringify(ustate->tcase->input, "");
+		fprintf(stderr, "Could not parse options: %s\n", tc_str);
+		cs_mem_free(tc_str);
+		return false;
+	}
+
+	cs_err err = cs_open(arch, mode, &ustate->handle);
+	if (err != CS_ERR_OK) {
+		char *tc_str = test_input_stringify(ustate->tcase->input, "");
+		fprintf(stderr,
+			"[!] cs_open() failed with: '%s'. TestInput: %s\n",
+			cs_strerror(err), tc_str);
+		cs_mem_free(tc_str);
+		return false;
+	}
+
+	// The bit mode must be set, otherwise the numbers are
+	// not normalized correctly in the asm-test comparison step.
+	if (arch == CS_ARCH_AARCH64 || mode & CS_MODE_64) {
+		ustate->arch_bits = 64;
+	} else if (mode & CS_MODE_16) {
+		ustate->arch_bits = 16;
+	} else {
+		ustate->arch_bits = 32;
+	}
+
+	for (size_t i = 0; i < options_set; ++i) {
+		err = cs_option(ustate->handle, options[i].type,
+				options[i].val);
+		if (err != CS_ERR_OK) {
+			goto option_error;
+		}
+	}
+	return true;
+
+option_error: {
+	char *tc_str = test_input_stringify(ustate->tcase->input, "");
+	fprintf(stderr, "[!] cs_option() failed with: '%s'. TestInput: %s\n",
+		cs_strerror(err), tc_str);
+	cs_mem_free(tc_str);
+	cs_close(&ustate->handle);
+	return false;
+}
+}
+
+static int cstest_unit_test_setup(void **state)
+{
+	assert(state);
+	UnitTestState *ustate = *state;
+	assert(ustate->tcase);
+	if (!open_cs_handle(ustate)) {
+		fail_msg("Failed to initialize Capstone with given options.");
+		return -1;
+	}
+	return 0;
+}
+
+static int cstest_unit_test_teardown(void **state)
+{
+	if (!state) {
+		return 0;
+	}
+	UnitTestState *ustate = *state;
+	if (ustate->handle) {
+		cs_err err = cs_close(&ustate->handle);
+		if (err != CS_ERR_OK) {
+			fail_msg("cs_close() failed with: '%s'.",
+				 cs_strerror(err));
+			return -1;
+		}
+	}
+	return 0;
+}
+
+static void cstest_unit_test(void **state)
+{
+	assert(state);
+	UnitTestState *ustate = *state;
+	assert(ustate);
+	assert(ustate->handle);
+	assert(ustate->tcase);
+	csh handle = ustate->handle;
+	TestCase *tcase = ustate->tcase;
+
+	cs_insn *insns = NULL;
+	size_t insns_count = cs_disasm(handle, tcase->input->bytes,
+				       tcase->input->bytes_count,
+				       tcase->input->address, 0, &insns);
+	test_expected_compare(&ustate->handle, tcase->expected, insns,
+			      insns_count, ustate->arch_bits);
+	ustate->decoded_insns += insns_count;
+	cs_free(insns, insns_count);
+}
+
+static void eval_test_cases(TestFile **test_files, TestRunStats *stats)
+{
+	assert(test_files && stats);
+	// CMocka's API doesn't allow to init a CMUnitTest with a partially initialized state
+	// (which is later initialized in the test setup).
+	// So we do it manually here.
+	struct CMUnitTest *utest_table =
+		cs_mem_calloc(sizeof(struct CMUnitTest),
+			      stats->tc_total); // Number of test cases.
+
+	char utest_id[128] = { 0 };
+
+	size_t tci = 0;
+	for (size_t i = 0; i < stats->valid_test_files; ++i) {
+		TestCase **test_cases = test_files[i]->test_cases;
+		const char *filename = test_files[i]->filename ?
+					       test_files[i]->filename :
+					       NULL;
+
+		for (size_t k = 0; k < test_files[i]->test_cases_count;
+		     ++k, ++tci) {
+			cs_snprintf(utest_id, sizeof(utest_id),
+				    "%s - TC #%" PRIx32 ": ", filename, k);
+			if (test_cases[k]->skip) {
+				char *tc_name = test_input_stringify(
+					test_cases[k]->input, utest_id);
+				fprintf(stderr, "SKIP: %s\nReason: %s\n",
+					tc_name, test_cases[k]->skip_reason);
+				cs_mem_free(tc_name);
+				stats->skipped++;
+				continue;
+			}
+
+			UnitTestState *ut_state =
+				cs_mem_calloc(sizeof(UnitTestState), 1);
+			ut_state->tcase = test_cases[k];
+			utest_table[tci].name = test_input_stringify(
+				ut_state->tcase->input, utest_id);
+			utest_table[tci].initial_state = ut_state;
+			utest_table[tci].setup_func = cstest_unit_test_setup;
+			utest_table[tci].teardown_func =
+				cstest_unit_test_teardown;
+			utest_table[tci].test_func = cstest_unit_test;
+		}
+	}
+	assert(tci == stats->tc_total);
+	// Use private function here, because the API takes only constant tables.
+	int failed_tests = _cmocka_run_group_tests(
+		"All test cases", utest_table, stats->tc_total, NULL, NULL);
+	assert(failed_tests >= 0 && "Faulty return value");
+
+	for (size_t i = 0; i < stats->tc_total; ++i) {
+		UnitTestState *ustate = utest_table[i].initial_state;
+		if (!ustate) {
+			// Skipped test case
+			continue;
+		}
+		stats->decoded_insns += ustate->decoded_insns;
+		cs_mem_free((char *)utest_table[i].name);
+		cs_mem_free(utest_table[i].initial_state);
+	}
+	cs_mem_free(utest_table);
+	stats->failed += failed_tests;
+	stats->successful += stats->tc_total - failed_tests - stats->skipped;
+}
+
+/// Runs runs all valid tests in the given @test_files
+/// and returns the result as well as statistics in @stats.
+TestRunResult cstest_run_tests(char **test_file_paths, uint32_t path_count,
+			       TestRunStats *stats)
+{
+	TestFile **files = parse_test_files(test_file_paths, path_count, stats);
+	if (!files) {
+		return get_test_run_result(stats);
+	}
+	eval_test_cases(files, stats);
+	for (size_t i = 0; i < stats->valid_test_files; ++i) {
+		test_file_free(files[i]);
+	}
+	cs_mem_free(files);
+
+	return get_test_run_result(stats);
+}