Files
VCCPlusOSS/platforms/macos/Tests/HardDiskCoreTests.mm
T

142 lines
8.4 KiB
Plaintext

// SPDX-License-Identifier: GPL-3.0-or-later
#import <XCTest/XCTest.h>
#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<std::uint8_t,65536> 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<std::uint8_t>(512)));
hard.mount(1,HardDiskImage(std::vector<std::uint8_t>(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<std::uint8_t>(8192));
for(unsigned i=0;i<4;++i) floppy.mount(i,DiskImage::load(std::vector<std::uint8_t>(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<std::uint8_t>(257)); } catch (const std::invalid_argument&) { rejected = true; }
XCTAssertTrue(rejected);
HardDiskImage image(std::vector<std::uint8_t>(512, 0x11));
std::array<std::uint8_t,256> 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<std::uint8_t>(512,0x17)));
disk.mount(1,HardDiskImage(std::vector<std::uint8_t>(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<HardDiskDevice>();
auto floppy = std::make_shared<Fd502Device>(std::vector<std::uint8_t>(8192));
hard->mount(0,HardDiskImage(std::vector<std::uint8_t>(4096)));
session.cartridges().configure({nullptr,hard,nullptr,nullptr,floppy},true,4);
std::vector<std::uint8_t> 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