Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,141 @@
|
||||
// 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
|
||||
Reference in new issue
Block a user