// Klaus Dormann's 6502/65C02 functional tests, run against the CPU core.

//

// Covers sequential composition: ~30 million instructions of interdependent

// code, rather than instructions considered one at a time. Not the per-opcode

// oracle -- ProcessorTests is -- and it reports a single trap address for a

// whole run.

//

// No timing coverage: it verifies results, not cycle counts. mutation_check.py

// confirms that by dropping the page-cross penalty and watching this pass.

//

// The .bin is a full 64K image, execution starts at $0400, and the program

// traps by branching to itself. Success is a trap at one specific address from

// the listing; a trap anywhere else means a check failed there.

//

// Binaries are fetched by tests/fetch_klaus.py rather than committed: GPL and

// 64K each. Without them this reports skipped.

#include "support/cpu_fixture.h"

#include "support/harness.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// Where a passing run comes to rest, per bin_files/*.lst in Klaus's repo.

#define FUNCTIONAL_SUCCESS 0x3469

#define EXTENDED_SUCCESS   0x24F1

#define START_PC 0x0400

// The images are full 64K memory dumps. Named rather than taken from the

// fixture's memory size, which is now the 65C816's whole 24-bit space.

#define KLAUS_IMAGE_SIZE 0x10000

// Generous: a full functional run is tens of millions of instructions, and the

// point of the ceiling is only to stop a broken core spinning forever.

#define MAX_INSTRUCTIONS 200000000u

static const char *

find_binary(const char *name, char *buf, size_t buflen)

{

	// Run from the build directory or the source root, so try both.

	const char *prefixes[] = { "tests/klaus/", "../tests/klaus/", "klaus/" };

	for (size_t i = 0; i < sizeof prefixes / sizeof prefixes[0]; i++) {

		snprintf(buf, buflen, "%s%s", prefixes[i], name);

		FILE *f = fopen(buf, "rb");

		if (f) {

			fclose(f);

			return buf;

		}

	}

	return NULL;

}

// Run one test image. Returns the address it trapped at, or 0 if it never did.

static uint16_t

run_image(const char *path, bool c816)

{

	FILE *f = fopen(path, "rb");

	if (!f) {

		return 0;

	}

	cpu_reset_to(c816 ? CPU_816_EMU : CPU_65C02, START_PC);

	size_t got = fread(cpu_mem, 1, KLAUS_IMAGE_SIZE, f);

	fclose(f);

	if (got != KLAUS_IMAGE_SIZE) {

		printf("     image is %zu bytes, expected %d\n", got, KLAUS_IMAGE_SIZE);

		return 0;

	}

	// The image includes its own vectors, but execution starts at a fixed

	// address rather than through reset.

	regs.pc = START_PC;

	uint16_t prev_pc = regs.pc;

	for (uint32_t i = 0; i < MAX_INSTRUCTIONS; i++) {

		cpu_steps(1);

		if (regs.pc == prev_pc) {

			return regs.pc; // branched to itself: a trap, pass or fail

		}

		prev_pc = regs.pc;

	}

	return 0;

}

// Print the source around the address the test stopped at.

//

// A trap address on its own is close to useless: it means opening a listing of

// several hundred thousand lines and searching by hand. The listing maps the

// address straight back to the check that failed, and the lines above it say

// which opcode was under test, so print them.

static void

print_listing_context(const char *bin_name, uint16_t addr)

{

	char lst_name[128];

	char path[256];

	// 6502_functional_test.bin -> 6502_functional_test.lst

	snprintf(lst_name, sizeof lst_name, "%.*s.lst",

	         (int)(strlen(bin_name) - 4), bin_name);

	if (!find_binary(lst_name, path, sizeof path)) {

		printf("     (%s not fetched; re-run tests/fetch_klaus.py for the source)\n",

		       lst_name);

		return;

	}

	FILE *f = fopen(path, "r");

	if (!f) {

		return;

	}

	// Keep a window of what came before, since the interesting part -- the

	// opcode being tested -- is above the line that trapped.

	enum { BEFORE = 14 };

	static char ring[BEFORE][256];

	int    count = 0;

	char   line[256];

	char   want[8];

	snprintf(want, sizeof want, "%04x :", addr);

	while (fgets(line, sizeof line, f)) {

		if (strncmp(line, want, strlen(want)) == 0) {

			printf("     --- %s around $%04X ---\n", lst_name, addr);

			int first = count > BEFORE ? count - BEFORE : 0;

			for (int i = first; i < count; i++) {

				printf("     %s", ring[i % BEFORE]);

			}

			printf("  >> %s", line);

			for (int i = 0; i < 2 && fgets(line, sizeof line, f); i++) {

				printf("     %s", line);

			}

			printf("     --- end ---\n");

			fclose(f);

			return;

		}

		snprintf(ring[count % BEFORE], sizeof ring[0], "%s", line);

		count++;

	}

	fclose(f);

	printf("     ($%04X not found in %s)\n", addr, lst_name);

}

// Whether a missing image is a failure rather than a skip. CI sets this, so a

// broken or deleted fetch step shows up as a red test instead of a green run

// that quietly checked nothing. Locally it is unset, and the images stay

// optional.

static bool

images_required(void)

{

	const char *v = getenv("X16_KLAUS_REQUIRED");

	return v != NULL && v[0] != '\0' && v[0] != '0';

}

static void

run_case(const char *name, uint16_t expected_success, const char *divergence)

{

	char path[256];

	char label[192];

	if (!find_binary(name, path, sizeof path)) {

		if (images_required()) {

			snprintf(label, sizeof label,

			         "%s is present (X16_KLAUS_REQUIRED is set)", name);

			check(false, label);

			printf("     run tests/fetch_klaus.py, or unset X16_KLAUS_REQUIRED\n");

		} else {

			printf("skip: %s not present (run tests/fetch_klaus.py)\n", name);

		}

		return;

	}

	printf("     running %s\n", path);

	uint16_t trap = run_image(path, false);

	bool passed = (trap == expected_success);

	snprintf(label, sizeof label, "%s traps at $%04X, expected $%04X",

	         name, trap, expected_success);

	if (divergence != NULL) {

		check_divergent(passed, label, divergence);

	} else {

		check(passed, label);

	}

	if (!passed) {

		printf("     A=$%02X X=$%02X Y=$%02X SP=$%04X P=$%02X after %s\n",

		       regs.a, regs.xl, regs.yl, regs.sp, regs.status, name);

		print_listing_context(name, trap);

	}

}

int

main(void)

{

	// Documented opcodes and addressing modes. This is the one that gates.

	run_case("6502_functional_test.bin", FUNCTIONAL_SUCCESS, NULL);

	// The extended test also exercises undefined opcodes, checking their byte

	// counts by putting INY instructions in the bytes a correctly sized opcode

	// would skip. It failed while $5C, $DC and $FC were one-byte implied NOPs

	// rather than three-byte ones, because the operand bytes were executed

	// instead of skipped.

	run_case("65C02_extended_opcodes_test.bin", EXTENDED_SUCCESS, NULL);

	return x16_test_summary("klaus");

}