// SPDX-License-Identifier: GPL-3.0-or-later #import #include "../../../src/devices/HardDisk/HardDiskDevice.h" #include "../../../src/devices/FD502/Fd502Device.h" #include "../../../src/core/MachineSession.h" #include "../../../src/core/tcc1014mmu.h" using namespace VCC::Devices; namespace { struct HardHost : DeviceHost { std::array memory{}; void cartridgeNmi() override {} std::uint8_t cartridgeReadMemory(std::uint16_t address) override { return memory[address]; } void cartridgeWriteMemory(std::uint16_t address, std::uint8_t value) override { memory[address] = value; } }; void unlock(VirtualClock& clock) { for (unsigned bit = 0; bit < 64; ++bit) clock.read(0x78 | ((0x5ca33ac55ca33ac5ULL >> bit) & 1)); } std::uint64_t readClock(VirtualClock& clock) { unlock(clock); std::uint64_t result = 0; for (unsigned bit = 0; bit < 64; ++bit) result |= std::uint64_t(clock.read(0x7c)) << bit; return result; } void writeClock(VirtualClock& clock, std::uint64_t packet) { unlock(clock); for (unsigned bit = 0; bit < 64; ++bit) clock.read(0x78 | ((packet >> bit) & 1)); } } @interface HardDiskCoreTests : XCTestCase @end @implementation HardDiskCoreTests - (void)testGuestActivityIsIndependentPerMediumAndIgnoresHostSaves { HardHost host; HardDiskDevice hard; hard.mount(0,HardDiskImage(std::vector(512))); hard.mount(1,HardDiskImage(std::vector(512),true)); hard.writePort(0x83,0,host); XCTAssertEqual(hard.readEvents(0),1u); XCTAssertEqual(hard.readEvents(1),0u); hard.writePort(0x83,1,host); XCTAssertEqual(hard.writeEvents(0),1u); XCTAssertFalse(hard.image(0)->dirty(), "Writing identical bytes is still a real guest write"); hard.image(0)->capture(); hard.writePort(0x83,2,host); XCTAssertEqual(hard.readEvents(0),1u); XCTAssertEqual(hard.writeEvents(0),1u); hard.writePort(0x86,1,host); hard.writePort(0x83,1,host); XCTAssertEqual(hard.writeEvents(1),0u); hard.writePort(0x83,0,host); XCTAssertEqual(hard.readEvents(1),1u); hard.reset(); XCTAssertEqual(hard.readEvents(1),1u); Fd502Device floppy(std::vector(8192)); for(unsigned i=0;i<4;++i) floppy.mount(i,DiskImage::load(std::vector(161280))); const unsigned selects[]{1,2,4,0x40}; for(unsigned i=0;i<4;++i) { floppy.writePort(0x40,selects[i]|8,host); for(unsigned t=0;t<20;++t) floppy.horizontalSync(host); XCTAssertEqual(floppy.readEvents(i),0u); XCTAssertEqual(floppy.writeEvents(i),0u); floppy.writePort(0x4a,1,host); floppy.writePort(0x48,0x80,host); for(unsigned b=0;b<256;++b) floppy.readPort(0x4b,host); for(unsigned t=0;t<8;++t) floppy.horizontalSync(host); XCTAssertEqual(floppy.readEvents(i),256u); XCTAssertEqual(floppy.writeEvents(i),0u); floppy.writePort(0x4a,1,host); floppy.writePort(0x48,0xa0,host); for(unsigned b=0;b<256;++b) floppy.writePort(0x4b,0,host); for(unsigned t=0;t<12;++t) floppy.horizontalSync(host); XCTAssertEqual(floppy.writeEvents(i),256u); floppy.markSaved(i);XCTAssertEqual(floppy.writeEvents(i),256u); } VCC::Mac::CassetteDeck tape; tape.mount({0x55},VCC::Mac::TapeFormat::CAS);tape.motor(true); for(unsigned i=0;i<100;++i) tape.tick(128); XCTAssertEqual(tape.snapshot().readEvents,0u); tape.play();for(unsigned i=0;i<30001;++i) tape.tick(128); XCTAssertEqual(tape.snapshot().readEvents,1u); tape.stop();for(unsigned i=0;i<100;++i) tape.tick(128); XCTAssertEqual(tape.snapshot().readEvents,1u); tape.record(VCC::Mac::TapeFormat::WAV);tape.motor(false);tape.tick(255); XCTAssertEqual(tape.snapshot().writeEvents,0u); tape.motor(true);tape.tick(255);XCTAssertEqual(tape.snapshot().writeEvents,1u); tape.exportImage();tape.markSaved();XCTAssertEqual(tape.snapshot().writeEvents,1u); } - (void)testImagesBoundsGrowthAndRevisionAcknowledgements { bool rejected = false; try { HardDiskImage bad(std::vector(257)); } catch (const std::invalid_argument&) { rejected = true; } XCTAssertTrue(rejected); HardDiskImage image(std::vector(512, 0x11)); std::array a, b; a.fill(0x5a); b.fill(0x6b); XCTAssertTrue(image.write(0, a)); auto first = image.capture(); XCTAssertTrue(image.write(0, b)); XCTAssertTrue(image.write(3, a)); image.acknowledge(first); XCTAssertTrue(image.dirty()); XCTAssertEqual(image.read(0)[0], 0x6b); XCTAssertEqual(image.read(2)[0], 0); XCTAssertEqual(image.bytes().size(), 1024u); auto second = image.capture(); image.acknowledge(second); XCTAssertFalse(image.dirty()); image.protect(true); XCTAssertFalse(image.write(1, a)); XCTAssertEqual(image.read(1)[0], 0x11); XCTAssertEqual(image.read(HardDiskImage::maxBytes/256-1)[0], 0); XCTAssertFalse(image.write(HardDiskImage::maxBytes/256, a)); auto blank = HardDiskImage::blank(1024); XCTAssertTrue(blank.dirty()); blank.acknowledge(blank.capture()); XCTAssertFalse(blank.dirty()); } - (void)testRegistersStatusDMAAndProtection { HardHost host; HardDiskDevice disk; auto w = [&](unsigned p, unsigned v) { disk.writePort(p,v,host); }; auto r = [&](unsigned p) { return disk.readPort(p,host); }; XCTAssertEqual(r(0x83), 255); w(0x83,0); XCTAssertEqual(r(0x83), 4); disk.mount(0,HardDiskImage(std::vector(512,0x17))); disk.mount(1,HardDiskImage(std::vector(512,0x29),true)); w(0x84,0xff); w(0x85,0x80); w(0x83,0); XCTAssertEqual(host.memory[0xff80], 0x17); XCTAssertEqual(host.memory[0x007f], 0x17); w(0x86,1); w(0x86,255); XCTAssertEqual(r(0x86),1); w(0x83,1); XCTAssertEqual(r(0x83),5); XCTAssertFalse(disk.image(1)->dirty()); w(0x83,7); XCTAssertEqual(r(0x83),254); w(0x82,10); w(0x83,0); XCTAssertEqual(r(0x83),0); XCTAssertEqual(host.memory[0xff80],0); w(0x80,0x20); w(0x81,0); w(0x82,0); w(0x83,0); XCTAssertEqual(r(0x83),4); w(0x83,2); XCTAssertEqual(r(0x80),0); XCTAssertEqual(r(0x84),0); XCTAssertEqual(disk.flushRequests(),1u); disk.reset(); XCTAssertEqual(r(0x86),0); XCTAssertEqual(r(0x83),255); XCTAssertTrue(disk.image(0) != nullptr); XCTAssertEqual(r(0x60),0); } - (void)testGuestDMAInMPIOnBothCPUs { for (auto cpu : {VCC::Mac::Processor::MC6809,VCC::Mac::Processor::HD6309}) { VCC::Mac::MachineSession session; auto hard = std::make_shared(); auto floppy = std::make_shared(std::vector(8192)); hard->mount(0,HardDiskImage(std::vector(4096))); session.cartridges().configure({nullptr,hard,nullptr,nullptr,floppy},true,4); std::vector rom(32768); // Fill 256 bytes spanning an MMU bank, write LSN 1, read it elsewhere. const std::uint8_t code[]{0x8e,0x1f,0x80,0x86,0x5a,0xa7,0x80,0x8c,0x20,0x80,0x26,0xf9, 0x86,1,0xb7,0xff,0x82,0x86,0x1f,0xb7,0xff,0x84,0x86,0x80,0xb7,0xff,0x85, 0x86,1,0xb7,0xff,0x83,0x86,0x2f,0xb7,0xff,0x84,0x86,0,0xb7,0xff,0x83,0x20,0xfe}; std::copy(std::begin(code),std::end(code),rom.begin()); rom[32766]=0x80; session.load(rom,cpu); session.resume(); session.advance(); XCTAssertEqual(hard->result(),0); XCTAssertTrue(hard->image(0)->dirty()); for (unsigned i = 0; i < 256; ++i) { XCTAssertEqual(MemRead8(0x2f80+i),0x5a); XCTAssertEqual(hard->image(0)->read(1)[i],0x5a); } session.softReset(); XCTAssertTrue(hard->image(0)->dirty()); XCTAssertEqual(session.cartridges().romSlot(),4u); } } - (void)testClockProtocolAndVirtualWrites { std::tm date{}; date.tm_year=126; date.tm_mon=10; date.tm_mday=1; date.tm_hour=13; date.tm_min=24; date.tm_sec=35; date.tm_isdst=-1; auto fixed = std::mktime(&date); VirtualClock clock([fixed] { return fixed; }); auto before = readClock(clock); XCTAssertEqual((before>>56)&255,0xc6); XCTAssertEqual((before>>48)&255,0x11); XCTAssertEqual((before>>24)&255,0x13); XCTAssertEqual((before>>8)&255,0x35); auto changed = (before & ~(0xffffULL<<8)) | (0x4521ULL<<8); writeClock(clock,changed); XCTAssertEqual(readClock(clock),before); clock.setReadOnly(false); writeClock(clock,changed); XCTAssertEqual(readClock(clock),changed); clock.reset(); XCTAssertEqual(readClock(clock),changed); HardHost host; HardDiskDevice disk; disk.configureClock(false,true); for (unsigned bit=0;bit<64;++bit) disk.readPort(0x78|((0x5ca33ac55ca33ac5ULL>>bit)&1),host); XCTAssertEqual(disk.readPort(0x7c,host),0); } @end