// SPDX-License-Identifier: GPL-3.0-or-later #import #include "../../../src/devices/RomCartridge.h" #include "../../../src/devices/RamDiskDevice.h" #include "../../../src/devices/Orchestra90Device.h" #include "../../../src/devices/SpeechSoundDevice.h" #include "../../../src/devices/FD502/Fd502Device.h" #include "../../../src/core/MachineSession.h" #include "../../../src/core/tcc1014mmu.h" #include "../../../src/core/mc6821.h" using namespace VCC::Devices; namespace { struct Host : DeviceHost { unsigned nmis = 0; bool line = false; void cartridgeNmi() override { ++nmis; } void cartridgeLine(bool value) override { line = value; } }; struct Probe : CartridgeDevice { unsigned ticks = 0, writes = 0, resets = 0; std::uint8_t value; bool line; std::uint16_t sample; Probe(unsigned value, bool line = false, unsigned sample = 0) : value(value), line(line), sample(sample) {} void reset() override { ++resets; } void horizontalSync(DeviceHost& host) override { ++ticks; host.cartridgeNmi(); } std::uint8_t readMemory(std::uint16_t) const override { return value; } std::uint8_t readPort(std::uint8_t, DeviceHost&) override { return value; } void writePort(std::uint8_t, std::uint8_t, DeviceHost&) override { ++writes; } bool cartLine() const override { return line; } std::uint16_t audio() const override { return sample; } }; } @interface CartridgeTests : XCTestCase @end @implementation CartridgeTests - (void)testSpeechSoundROMValidationBusIsolationAndAudioClock { Host host; SpeechSoundDevice missing; XCTAssertFalse(missing.ready()); XCTAssertFalse(missing.cartLine()); missing.advanceAudio(); XCTAssertEqual(missing.audioTicks(),0u); XCTAssertEqual(missing.audio(),0); bool rejected=false; try { SpeechSoundDevice bad(std::vector(4096)); } catch(const std::invalid_argument&) { rejected=true; } XCTAssertTrue(rejected); std::vector rom(6144,0);rom[0]=0xb3;rom[1]=0xe0;rom[2]=0xfd;rom[4094]=0xf0; auto device=std::make_shared(rom), inactive=std::make_shared(rom); XCTAssertTrue(device->ready()); XCTAssertFalse(device->cartLine()); XCTAssertEqual(device->readMemory(0xc000),0xff); for(unsigned p=0;p<256;++p) if(p!=0x7d && p!=0x7e) XCTAssertEqual(device->readPort(p,host),0); CartridgeBus bus;bus.connect(&host);bus.configure({inactive,nullptr,device,nullptr,nullptr},true,4); bus.writePort(0x7e,65);XCTAssertEqual(device->diagnostics().CommandCount(),1u); XCTAssertEqual(inactive->diagnostics().CommandCount(),0u);XCTAssertEqual(bus.readPort(0x7e)&128,0); for(unsigned i=0;i<500;++i){bus.horizontalSync();bus.audio();} XCTAssertEqual(device->audioTicks(),0u,"Scanlines and snapshot reads must not advance audio"); for(unsigned i=0;i<44100;++i)bus.advanceAudio(); XCTAssertEqual(device->audioTicks(),44100u);XCTAssertEqual(inactive->audioTicks(),0u); XCTAssertEqual(device->diagnostics().CpuIllegalCount(),0u); bus.writePort(0x7d,0);XCTAssertNotEqual(bus.readPort(0x7e)&128,0); bus.configure({inactive,nullptr,device,nullptr,nullptr},false,4);bus.advanceAudio(); XCTAssertEqual(inactive->audioTicks(),1u);XCTAssertEqual(device->audioTicks(),0u); const auto created = makeDevice(DeviceKind::SpeechSound,rom); XCTAssertNotEqual(created.get(),nullptr); } - (void)testSpeechSoundAdvancesAtSampleRateOnBothGuestProcessors { using namespace VCC::Mac; std::vector rom(6144,0);rom[0]=0xb3;rom[1]=0xe0;rom[2]=0xfd;rom[4094]=0xf0; for(auto cpu:{Processor::MC6809,Processor::HD6309}) { MachineSession session;auto device=std::make_shared(rom); session.cartridges().configure({nullptr,device,nullptr,nullptr,nullptr},true,4); session.loadDiagnostic(cpu);session.resume(); std::uint64_t samples=0; for(unsigned i=0;i<60;++i){session.advance();samples+=session.takeAudio().size();} XCTAssertEqual(device->audioTicks(),samples);XCTAssertGreaterThan(samples,44000u);XCTAssertLessThan(samples,45000u); session.pause();auto ticks=device->audioTicks();session.advance();XCTAssertEqual(device->audioTicks(),ticks); session.softReset();XCTAssertEqual(device->audioTicks(),0u); session.resume();session.advance();XCTAssertGreaterThan(device->audioTicks(),0u); session.reset();XCTAssertEqual(device->audioTicks(),0u); } } - (void)testOrchestraRegistersROMResetAndBroadcastRouting { Host host; Orchestra90Device bare; XCTAssertFalse(bare.cartLine()); XCTAssertEqual(bare.readMemory(0xc000), 0xff); XCTAssertEqual(bare.audio(), 0); bare.writePort(0x7a, 0x23, host); bare.writePort(0x7b, 0xc1, host); bare.writePort(0x40, 0xff, host); bare.reset(); XCTAssertEqual(bare.audio(), 0x23c1); for (unsigned p = 0; p < 256; ++p) XCTAssertEqual(bare.readPort(p, host), 0); std::vector rom(8192, 0x12); rom[0]=0x43; rom[8191]=0x78; auto sound = std::make_shared(rom); XCTAssertTrue(sound->cartLine()); XCTAssertEqual(sound->readMemory(0xc000), 0x43); XCTAssertEqual(sound->readMemory(0xffff), 0x78); XCTAssertEqual(sound->readMemory(0xe000), 0x43); bool rejected = false; try { Orchestra90Device invalid(std::vector(8193)); } catch (const std::invalid_argument&) { rejected = true; } XCTAssertTrue(rejected); auto idle = std::make_shared(0x55, false, 0x8080); auto inactive = std::make_shared(); CartridgeBus bus; bus.connect(&host); bus.configure({inactive,sound,nullptr,nullptr,idle},true,4); XCTAssertFalse(host.line); XCTAssertEqual(bus.readMemory(0xc000), 0x55); bus.writePort(0x7a, 0x21); bus.writePort(0x7b, 0xd3); XCTAssertEqual(bus.audio(), 0x21d3); XCTAssertEqual(inactive->audio(), 0); bus.writePort(0x7f, 0x03); // CTS1, SCS4; sound ports are broadcast regardless. XCTAssertTrue(host.line); XCTAssertEqual(bus.readMemory(0xc000), 0x43); bus.writePort(0x7a, 0x00); bus.writePort(0x7b, 0xff); XCTAssertEqual(bus.audio(), 0x00ff, @"Right channel must not carry into left"); bus.reset(); XCTAssertEqual(sound->audio(), 0x00ff); bus.configure({inactive,sound,nullptr,nullptr,idle}, false, 4); XCTAssertEqual(bus.audio(), 0); bus.writePort(0x7a, 0x40); XCTAssertEqual(bus.audio(), 0x4000); XCTAssertEqual(sound->audio(), 0x00ff); XCTAssertEqual(makeDevice(DeviceKind::Orchestra90, rom)->readMemory(0xe000), 0x43); } - (void)testGuestOrchestraStereoReachesPCMOnBothProcessors { using namespace VCC::Mac; for (auto cpu : {Processor::MC6809, Processor::HD6309}) { MachineSession session; auto sound = std::make_shared(); session.cartridges().configure({nullptr,sound,nullptr,nullptr,nullptr}, true, 4); session.loadDiagnostic(cpu); // Authored guest toggles exactly one DAC; the other must stay silent. for (auto port : {0x7b, 0x7a}) { session.cartridges().writePort(0x7a, 0); session.cartridges().writePort(0x7b, 0); std::vector code{0x86,0x40,0xb7,0xff,std::uint8_t(port), 0x8e,0x01,0x00,0x30,0x1f,0x26,0xfc,0x88,0x80,0x20,0xf2}; std::vector binary{0,0,std::uint8_t(code.size()),0x30,0}; binary.insert(binary.end(),code.begin(),code.end()); binary.insert(binary.end(),{0xff,0,0,0x30,0}); session.quickLoad(binary); session.advance(); session.takeAudio(); session.advance(); auto samples = session.takeAudio(); XCTAssertGreaterThan(samples.size(), 700u); bool low = false, high = false; for (const auto sample : samples) { auto active = port == 0x7a ? sample.left : sample.right; auto silent = port == 0x7a ? sample.right : sample.left; XCTAssertEqual(silent, 0.0f); XCTAssertTrue(active == .25f || active == .75f); low |= active == .25f; high |= active == .75f; } XCTAssertTrue(low && high); AudioBuffer buffer; buffer.gain = .5f; buffer.write(samples.data(), samples.size()); std::vector left(samples.size()), right(samples.size()); buffer.read(left.data(),right.data(),samples.size()); XCTAssertEqual(left[0], samples[0].left * .5f); XCTAssertEqual(right[0], samples[0].right * .5f); buffer.gain = 0; buffer.write(samples.data(), samples.size()); buffer.read(left.data(),right.data(),samples.size()); XCTAssertTrue(std::all_of(left.begin(),left.end(),[](float v){return v==0;})); XCTAssertTrue(std::all_of(right.begin(),right.end(),[](float v){return v==0;})); session.pause(); session.advance(); XCTAssertTrue(session.takeAudio().empty()); const auto latched = sound->audio(); session.softReset(); XCTAssertEqual(sound->audio(),latched); session.reset(); XCTAssertEqual(sound->audio(),latched); } } } - (void)testRamDiskRegistersIsolationAndResetMatchLegacy { Host host; RamDiskDevice first, second; for (unsigned bank = 0; bank < 8; ++bank) { first.writePort(0x40, 0xff, host); first.writePort(0x41, 0xff, host); first.writePort(0x42, bank, host); first.writePort(0x43, 0xa0 + bank, host); } for (unsigned bank = 0; bank < 8; ++bank) { first.writePort(0x42, bank | 0xf8, host); XCTAssertEqual(first.readPort(0x43, host), 0xa0 + bank); XCTAssertEqual(first.readPort(0x43, host), 0xa0 + bank, @"Read must not advance the address"); XCTAssertEqual(first.readPort(0x40, host), 0); } first.reset(); XCTAssertEqual(first.readPort(0x43, host), 0xa7, @"Reset retains the data and all address latches"); XCTAssertEqual(second.readPort(0x43, host), 0); XCTAssertEqual(first.readMemory(0xc000), 0); XCTAssertFalse(first.cartLine()); XCTAssertEqual(first.audio(), 0); first.horizontalSync(host); XCTAssertEqual(host.nmis, 0u); auto fresh = makeDevice(DeviceKind::RamDisk, {}); XCTAssertEqual(fresh->readPort(0x43, host), 0); } - (void)testGuestRAMDiskWritesAndReadsOnBothCPUsWithIndependentROMRouting { for (auto cpu : {VCC::Mac::Processor::MC6809, VCC::Mac::Processor::HD6309}) { VCC::Mac::MachineSession session; auto ram = std::make_shared(); auto rom = std::make_shared(std::vector(8192, 0x67)); session.cartridges().configure({nullptr,ram,nullptr,nullptr,rom}, true, 4); std::vector system(32768); // Keep CTS on ROM slot 4, route SCS to RAM disk slot 1; access its last byte. const std::uint8_t code[]{0x86,0x30,0xb7,0xff,0x7f, 0x86,0xff,0xb7,0xff,0x40,0xb7,0xff,0x41, 0x86,0xff,0xb7,0xff,0x42,0x86,0xa5,0xb7,0xff,0x43, 0xb6,0xff,0x43,0xb7,2,0,0xb6,0xc0,0,0xb7,2,1,0x20,0xfe}; std::copy(std::begin(code),std::end(code),system.begin()); system[32766]=0x80; session.load(system,cpu); session.resume(); session.advance(); session.pause(); XCTAssertEqual(MemRead8(0x200), 0xa5); XCTAssertEqual(MemRead8(0x201), 0x67); session.softReset(); session.cartridges().writePort(0x7f,0x30); XCTAssertEqual(session.cartridges().readPort(0x43), 0xa5); session.reset(); session.cartridges().writePort(0x7f,0x30); XCTAssertEqual(session.cartridges().readPort(0x43), 0xa5); session.cartridges().writePort(0x7f,0x33); session.cartridges().writePort(0x43,0x77); // Other SCS slot cannot write RAM disk. session.cartridges().writePort(0x7f,0x30); XCTAssertEqual(session.cartridges().readPort(0x43), 0xa5); } } - (void)testRawROMMappingBankingAndValidation { Host host; std::vector bytes(262144); for (unsigned i = 0; i < bytes.size(); ++i) bytes[i] = i / 16384; RomCartridge rom(bytes); XCTAssertEqual(rom.readMemory(0xc000), 1); XCTAssertEqual(rom.readMemory(0), 0); rom.writePort(0x40, 0xff, host); XCTAssertEqual(rom.readMemory(0), 15); XCTAssertEqual(rom.readMemory(0x4000), 0); rom.reset(); XCTAssertEqual(rom.readMemory(0), 0); XCTAssertTrue(rom.cartLine()); RomCartridge small({1,2,3}); XCTAssertEqual(small.readMemory(4), 2); bool empty = false, large = false; try { RomCartridge bad({}); } catch (const std::invalid_argument&) { empty = true; } try { RomCartridge bad(std::vector(262145)); } catch (const std::invalid_argument&) { large = true; } XCTAssertTrue(empty && large); } - (void)testMultiPakIndependentRoutingTicksInterruptsAndAudio { Host host; CartridgeBus bus; bus.connect(&host); auto single = std::make_shared(9); auto first = std::make_shared(1, true, 0x8080); auto last = std::make_shared(4, false, 0x8080); CartridgeBus::Slots slots{single,first,nullptr,nullptr,last}; bus.configure(slots, true, 4); XCTAssertEqual(bus.readPort(0x7f), 0x33); XCTAssertFalse(host.line); bus.writePort(0x7f, 0xc3); // masked CTS=slot1, SCS=slot4 XCTAssertEqual(bus.readPort(0x7f), 3); XCTAssertTrue(host.line); XCTAssertEqual(bus.readMemory(0), 1); XCTAssertEqual(bus.readPort(0x48), 4); bus.writePort(0x40, 7); XCTAssertEqual(first->writes, 0u); XCTAssertEqual(last->writes, 1u); bus.writePort(0x60, 8); XCTAssertEqual(first->writes, 1u); XCTAssertEqual(last->writes, 2u); XCTAssertEqual(bus.readPort(0x60), 1); XCTAssertEqual(bus.audio(), 0x8080); bus.horizontalSync(); XCTAssertEqual(host.nmis, 2u); XCTAssertEqual(first->ticks, 1u); XCTAssertEqual(last->ticks, 1u); XCTAssertEqual(single->ticks, 0u); bus.writePort(0x7f, 0x11); XCTAssertEqual(bus.readMemory(0), 0xff); XCTAssertFalse(host.line); bus.reset(); XCTAssertEqual(bus.readPort(0x7f), 0x33); bus.configure(slots, false, 4); XCTAssertEqual(bus.readMemory(0), 9); bus.writePort(0x7f, 0x11); XCTAssertEqual(bus.romSlot(), 0u); XCTAssertEqual(single->writes, 1u); bus.horizontalSync(); XCTAssertEqual(single->ticks, 1u); XCTAssertEqual(first->ticks, 1u); bus.configure(slots, true, 1); XCTAssertTrue(host.line); XCTAssertEqual(bus.readPort(0x7f), 0); slots[2] = first; bool rejected = false; try { bus.configure(slots, true, 2); } catch (const std::invalid_argument&) { rejected = true; } XCTAssertTrue(rejected); XCTAssertEqual(bus.readPort(0x7f), 0); } - (void)testSelectedROMDrivesPIACartridgeSignal { VCC::Mac::MachineSession session; auto rom = std::make_shared(std::vector(8192, 0x12)); CartridgeBus::Slots slots{nullptr,rom,nullptr,nullptr,nullptr}; session.cartridges().configure(slots, true, 1); session.loadDiagnostic(); SetCartAutoStart(1); irq_fs(0); XCTAssertTrue(pia1_read(0x23) & 0x80); session.cartridges().writePort(0x7f, 0x33); PiaReset(); irq_fs(0); XCTAssertFalse(pia1_read(0x23) & 0x80); session.cartridges().writePort(0x7f, 0x03); irq_fs(0); XCTAssertTrue(pia1_read(0x23) & 0x80); session.cartridges().configure(slots, false, 1); PiaReset(); irq_fs(0); XCTAssertFalse(pia1_read(0x23) & 0x80); } - (void)testGuestSelectsROMAndDiskSlotsOnBothCPUs { for (auto cpu : {VCC::Mac::Processor::MC6809, VCC::Mac::Processor::HD6309}) { VCC::Mac::MachineSession session; auto disk = std::make_shared(std::vector(8192, 0x44)); auto rom = std::make_shared(std::vector(8192, 0x67)); session.cartridges().configure({nullptr,rom,nullptr,nullptr,disk}, true, 4); std::vector system(32768); // LDA #$03; STA $FF7F; LDA $C000; STA $0200; // LDA $FF7F; STA $0201; loop. ROM and disk selection differ. const std::uint8_t code[]{0x86,3,0xb7,0xff,0x7f,0xb6,0xc0,0,0xb7,2,0, 0xb6,0xff,0x7f,0xb7,2,1,0x20,0xfe}; std::copy(std::begin(code),std::end(code),system.begin()); system[32766]=0x80; session.load(system,cpu); session.resume(); session.advance(); XCTAssertEqual(MemRead8(0x200), 0x67); XCTAssertEqual(MemRead8(0x201), 3); XCTAssertEqual(session.cartridges().ioSlot(), 4u); session.softReset(); XCTAssertEqual(session.cartridges().readPort(0x7f), 0x33); session.pause(); session.cartridges().configure({rom,nullptr,nullptr,nullptr,disk}, false, 4); XCTAssertEqual(session.cartridges().readMemory(0), 0x67); } } @end