// Regression: watching memory must not change what the machine does.

//

// The watchpoint hook sits in write6502(), on the path every store takes. It

// runs before the write and does not return early, which is what lets a store

// still land while the debugger is told about it -- but nothing pinned that,

// and "the debugger swallowed my write" is a bug that would look like the

// emulated program being wrong.

//

// The wider claim is the one that matters: setting a watchpoint changes nothing

// except that a break is reported. These compare a whole machine signature

// either side of it rather than a list of fields, because the failures worth

// catching are the ones nobody thought to name.

//

// memory.c, debug_core.c and the CPU core are real here; only the devices

// behind the I/O page are fakes.

#include "support/fake_devices.h"

#include "support/harness.h"

#include "support/signature.h"

#include "debug_core.h"

#include "memory.h"

#include <stdint.h>

// Declared locally for the same reason the other tests do it: the only

// declarations live in headers that reach SDL.

extern uint8_t *RAM;

extern uint32_t clockticks6502;

#define SCRATCH 0x0400

#define VERA_REG 0x9F23

// fake_devices.c counts these for us.

extern int fake_break_count;

static void

setup(void)

{

	fake_devices_reset();

	debug_wp_clear_all();

	fake_break_count = 0;

}

// ---- A watched store still reaches memory ----------------------------------

static void

test_watched_store_still_writes(void)

{

	setup();

	RAM[SCRATCH] = 0x00;

	debug_wp_add_for(SCRATCH, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	write6502(SCRATCH, 0, 0x5A);

	check_eq(RAM[SCRATCH], 0x5A, "a watched address still receives the store");

	check(fake_break_count > 0, "and the watchpoint reported a break");

}

// ---- A watched I/O store still reaches the device --------------------------

// The one most likely to break, because the device is behind another layer.

static void

test_watched_io_store_still_reaches_device(void)

{

	setup();

	debug_wp_add_for(VERA_REG, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	write6502(VERA_REG, 0, 0x77);

	check_eq(fake_dev[FAKE_VERA].writes, 1, "a watched I/O store still reaches VERA");

	check_eq(fake_dev[FAKE_VERA].last_value, 0x77, "with the value the program wrote");

	check(fake_break_count > 0, "and the watchpoint reported a break");

}

// ---- Watching an address does not change the store itself ------------------

static void

test_watch_does_not_alter_the_machine(void)

{

	// Run the same store with and without a watchpoint, and compare everything

	// except the break count, which is the one thing that should differ.

	setup();

	write6502(SCRATCH, 0, 0x11);

	write6502(VERA_REG, 0, 0x22);

	machine_sig_t unwatched = machine_signature();

	setup();

	debug_wp_add_for(SCRATCH, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	write6502(SCRATCH, 0, 0x11);

	write6502(VERA_REG, 0, 0x22);

	machine_sig_t watched = machine_signature();

	check(machine_sig_equal(unwatched, watched),

	      "a watchpoint changes nothing about the stores themselves");

}

// ---- A watchpoint elsewhere is inert ---------------------------------------

static void

test_unrelated_watch_is_inert(void)

{

	setup();

	write6502(SCRATCH, 0, 0x33);

	machine_sig_t clean = machine_signature();

	setup();

	debug_wp_add_for(0x0500, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	write6502(SCRATCH, 0, 0x33);

	machine_sig_t with_other = machine_signature();

	check(machine_sig_equal(clean, with_other),

	      "a watchpoint on another address leaves the machine alone");

	check_eq(fake_break_count, 0, "and does not report a break");

}

// ---- Watching costs no cycles ----------------------------------------------

// The scan runs on every store, so if it charged anything the whole machine

// would run slower whenever a watchpoint was set.

static void

test_watching_costs_no_cycles(void)

{

	setup();

	write6502(SCRATCH, 0, 0x44);

	uint32_t plain = clockticks6502;

	setup();

	debug_wp_add_for(SCRATCH, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	write6502(SCRATCH, 0, 0x44);

	check_eq(clockticks6502, plain, "a watched store costs the same as any other");

	// And on a slow I/O address, where a store does cost cycles.

	setup();

	write6502(0x9FA0, 0, 0x55);

	uint32_t io_plain = clockticks6502;

	setup();

	debug_wp_add_for(0x9FA0, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	write6502(0x9FA0, 0, 0x55);

	check_eq(clockticks6502, io_plain, "and a watched slow-I/O store costs the same");

}

// ---- A value filter decides when to break, not whether to write ------------

static void

test_value_filter_still_writes(void)

{

	setup();

	debug_wp_add_for(SCRATCH, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	debug_wp_set_value(SCRATCH, DEBUG_BANK_ANY, BPCMP_EQ, 0x99);

	write6502(SCRATCH, 0, 0x01);

	check_eq(RAM[SCRATCH], 0x01, "a store that fails the filter still writes");

	check_eq(fake_break_count, 0, "and reports no break");

	write6502(SCRATCH, 0, 0x99);

	check_eq(RAM[SCRATCH], 0x99, "a store that matches the filter also writes");

	check(fake_break_count > 0, "and reports a break");

}

// ---- An inactive watchpoint is inert ---------------------------------------

static void

test_inactive_watch_is_inert(void)

{

	setup();

	debug_wp_add_for(SCRATCH, 1, DEBUG_BANK_ANY, DEBUG_OWNER_CLI);

	debug_wp_set_active(SCRATCH, DEBUG_BANK_ANY, false);

	write6502(SCRATCH, 0, 0x66);

	check_eq(RAM[SCRATCH], 0x66, "a disabled watchpoint still lets the store through");

	check_eq(fake_break_count, 0, "and reports no break");

}

int

main(void)

{

	test_watched_store_still_writes();

	test_watched_io_store_still_reaches_device();

	test_watch_does_not_alter_the_machine();

	test_unrelated_watch_is_inert();

	test_watching_costs_no_cycles();

	test_value_filter_still_writes();

	test_inactive_watch_is_inert();

	return x16_test_summary("watchpoint_purity");

}