267 lines
16 KiB
Plaintext
267 lines
16 KiB
Plaintext
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
#import <XCTest/XCTest.h>
|
|
#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<std::uint8_t>(4096)); } catch(const std::invalid_argument&) { rejected=true; }
|
|
XCTAssertTrue(rejected);
|
|
std::vector<std::uint8_t> rom(6144,0);rom[0]=0xb3;rom[1]=0xe0;rom[2]=0xfd;rom[4094]=0xf0;
|
|
auto device=std::make_shared<SpeechSoundDevice>(rom), inactive=std::make_shared<SpeechSoundDevice>(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<std::uint8_t> 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<SpeechSoundDevice>(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<std::uint8_t> rom(8192, 0x12); rom[0]=0x43; rom[8191]=0x78;
|
|
auto sound = std::make_shared<Orchestra90Device>(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<std::uint8_t>(8193)); } catch (const std::invalid_argument&) { rejected = true; }
|
|
XCTAssertTrue(rejected);
|
|
auto idle = std::make_shared<Probe>(0x55, false, 0x8080);
|
|
auto inactive = std::make_shared<Orchestra90Device>();
|
|
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<Orchestra90Device>();
|
|
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<std::uint8_t> code{0x86,0x40,0xb7,0xff,std::uint8_t(port),
|
|
0x8e,0x01,0x00,0x30,0x1f,0x26,0xfc,0x88,0x80,0x20,0xf2};
|
|
std::vector<std::uint8_t> 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<float> 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<RamDiskDevice>();
|
|
auto rom = std::make_shared<RomCartridge>(std::vector<std::uint8_t>(8192, 0x67));
|
|
session.cartridges().configure({nullptr,ram,nullptr,nullptr,rom}, true, 4);
|
|
std::vector<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t>(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<Probe>(9);
|
|
auto first = std::make_shared<Probe>(1, true, 0x8080);
|
|
auto last = std::make_shared<Probe>(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<RomCartridge>(std::vector<std::uint8_t>(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<Fd502Device>(std::vector<std::uint8_t>(8192, 0x44));
|
|
auto rom = std::make_shared<RomCartridge>(std::vector<std::uint8_t>(8192, 0x67));
|
|
session.cartridges().configure({nullptr,rom,nullptr,nullptr,disk}, true, 4);
|
|
std::vector<std::uint8_t> 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
|