Files

217 lines
13 KiB
Plaintext

// SPDX-License-Identifier: GPL-3.0-or-later
#import <XCTest/XCTest.h>
#include "../../../src/devices/SDCDevice.h"
#include <filesystem>
#include <fstream>
#include <unistd.h>
using namespace VCC::Devices;
namespace {
struct SDCHost : DeviceHost { unsigned nmis=0; void cartridgeNmi() override { ++nmis; } };
struct CardFixture {
std::filesystem::path folder;
CardFixture() {
char path[]="/tmp/vcc-sdc-unit-XXXXXX";
auto made=mkdtemp(path); if(!made) throw std::runtime_error("temporary card failed");
folder=made;
}
~CardFixture() { std::error_code ec; std::filesystem::remove_all(folder,ec); }
void file(const std::string& name,const std::vector<std::uint8_t>& bytes) {
std::ofstream f(folder/name,std::ios::binary); f.write(reinterpret_cast<const char*>(bytes.data()),bytes.size());
}
void text(const std::string& name,const std::string& bytes) { file(name,{bytes.begin(),bytes.end()}); }
std::vector<std::uint8_t> read(const std::string& name) {
std::ifstream f(folder/name,std::ios::binary); return {std::istreambuf_iterator<char>(f),{}};
}
};
struct Wire {
SDCDevice& s; SDCHost host;
void w(unsigned port,unsigned value) { s.writePort(port,value,host); }
unsigned r(unsigned port) { return s.readPort(port,host); }
void mode() { w(0x40,0x43); }
void command(unsigned code,unsigned param=0) {
w(0x49,param>>16);w(0x4a,param>>8);w(0x4b,param);w(0x48,code);
}
unsigned extended(const std::string& str,unsigned drive=0,unsigned parameters=0) {
command(0xe0|drive,parameters);
for(unsigned i=0;i<256;++i)w(0x4a+(i&1),i<str.size()?static_cast<unsigned char>(str[i]):0);
return r(0x48);
}
std::vector<std::uint8_t> read(unsigned count,bool byte=false,bool reversed=false) {
std::vector<std::uint8_t> out;
for(unsigned i=0;i<count;++i)out.push_back(r(byte?0x4b:0x4a+((i&1)^(reversed?1:0))));
return out;
}
};
}
@interface SDCCoreTests : XCTestCase
@end
@implementation SDCCoreTests
- (void)testCaseInsensitiveMountWordAndByteTransfersAndActivity {
CardFixture f; std::vector<std::uint8_t> data(161280);
for(unsigned i=0;i<data.size();++i)data[i]=static_cast<std::uint8_t>(i*13+i/256);
f.file("Game.DsK",data);
SDCDevice s(std::vector<std::uint8_t>(8192,0x5a),f.folder.string()); Wire p{s};
XCTAssertEqual(s.readMemory(0xc000),0x5a);XCTAssertEqual(s.readMemory(0xe000),0x5a);
XCTAssertEqual(p.r(0x60),0u);p.mode();XCTAssertEqual(p.extended("M:game.dsk"),0u);
XCTAssertEqual(s.snapshot().drives[0].reads,0u);
p.command(0x80,1);XCTAssertEqual(p.r(0x48),3u);
auto word=p.read(256);XCTAssertTrue(std::equal(word.begin(),word.end(),data.begin()+256));
XCTAssertEqual(p.r(0x48),0u);XCTAssertEqual(s.snapshot().drives[0].reads,1u);
p.command(0x84,2);auto bytes=p.read(256,true);XCTAssertTrue(std::equal(bytes.begin(),bytes.end(),data.begin()+512));
p.command(0x80,0);auto reverse=p.read(256,false,true);
for(unsigned i=0;i<256;i+=2){XCTAssertEqual(reverse[i],data[i+1]);XCTAssertEqual(reverse[i+1],data[i]);}
XCTAssertEqual(s.snapshot().drives[0].reads,3u);XCTAssertEqual(s.snapshot().drives[1].reads,0u);
p.command(0x80,630);XCTAssertEqual(p.r(0x48),0x90u);XCTAssertEqual(s.snapshot().drives[0].reads,3u);
}
- (void)testCommandLatchReleaseClearsReplyAndParameters {
CardFixture card;
std::vector<std::uint8_t> image(161280);
image[0] = 0x13;
image[256] = 0x37;
card.file("DISK.DSK", image);
SDCDevice s({}, card.folder.string());
s.mount(0, "DISK.DSK");
Wire p{s};
p.mode();
p.command(0xc0, ('V' << 16) | 1);
XCTAssertEqual(p.r(0x4b), 1u);
p.w(0x40, 0);
p.mode();
for (unsigned port = 0x49; port <= 0x4b; ++port)
XCTAssertEqual(p.r(port), 0u);
// No new parameters: read LSN 0 of the still-mounted disk.
p.w(0x48, 0x80);
XCTAssertEqual(p.r(0x48), 3u);
XCTAssertEqual(p.read(256).front(), 0x13);
}
- (void)testProtectedAndWritableSectorsReopenAndBounds {
CardFixture f;f.file("SAVE.DSK",std::vector<std::uint8_t>(161280,0));
SDCDevice s({},f.folder.string());s.mount(0,"SAVE.DSK");Wire p{s};p.mode();
auto write=[&](unsigned lsn,unsigned byte){p.command(0xa0,lsn);for(unsigned i=0;i<256;++i)p.w(0x4a+(i&1),byte);};
write(0,0x66);XCTAssertEqual(p.r(0x48),0xc0u);XCTAssertEqual(f.read("SAVE.DSK")[0],0u);
XCTAssertEqual(s.snapshot().drives[0].writes,0u);s.setWriteProtected(false);
write(0,0x66);XCTAssertEqual(p.r(0x48),0u);XCTAssertEqual(f.read("SAVE.DSK")[0],0x66u);
write(631,0x77);XCTAssertEqual(p.r(0x48),0u);XCTAssertEqual(f.read("SAVE.DSK").size(),632u*256u);
write(0x200000,0x88);XCTAssertEqual(p.r(0x48),0x90u);
XCTAssertEqual(s.snapshot().drives[0].writes,2u);
SDCDevice reopened({},f.folder.string());reopened.mount(0,"SAVE.DSK");Wire q{reopened};q.mode();q.command(0x84,631);
auto got=q.read(256,true);XCTAssertTrue(std::all_of(got.begin(),got.end(),[](auto b){return b==0x77;}));
s.setWriteProtected(true);write(0,0x99);XCTAssertEqual(p.r(0x48),0xc0u);
}
- (void)testStreamingExactEndAbortAndSectorModeRestoration {
CardFixture f;std::vector<std::uint8_t> bytes(1024);for(unsigned i=0;i<bytes.size();++i)bytes[i]=i/256;
f.file("MUSIC.RAW",bytes);SDCDevice s({},f.folder.string());Wire p{s};p.mode();
XCTAssertEqual(p.extended("m:MUSIC.RAW"),0u);p.command(0x94);
auto stream=p.read(1024,true);XCTAssertTrue(stream==bytes);XCTAssertEqual(p.r(0x48),0u);
XCTAssertEqual(s.snapshot().drives[0].reads,2u);
p.command(0x90);p.read(14);p.command(0xd0);XCTAssertEqual(p.r(0x48),0u);
p.command(0x84,1);auto sector=p.read(256,true);XCTAssertTrue(std::all_of(sector.begin(),sector.end(),[](auto b){return b==1;}));
p.command(0x90,0x200000);XCTAssertEqual(p.r(0x48),0u); // past EOF ends without leaking uninitialized bytes
}
- (void)testExternalReplacementAndInPlaceChangesRejectWrites {
CardFixture f;f.file("SAVE.DSK",std::vector<std::uint8_t>(161280,0x11));
SDCDevice s({},f.folder.string(),false);s.mount(0,"SAVE.DSK");Wire p{s};p.mode();
auto write=[&]{p.command(0xa0,0);for(unsigned i=0;i<256;++i)p.w(0x4a+(i&1),0x99);};
f.file("NEW.DSK",std::vector<std::uint8_t>(161280,0x22));
std::filesystem::rename(f.folder/"NEW.DSK",f.folder/"SAVE.DSK");
write();XCTAssertEqual(p.r(0x48),0x88u);XCTAssertEqual(f.read("SAVE.DSK")[0],0x22u);
XCTAssertEqual(s.snapshot().drives[0].writes,0u);
s.mount(0,"SAVE.DSK");
f.file("SAVE.DSK",std::vector<std::uint8_t>(161024,0x33));
write();XCTAssertEqual(p.r(0x48),0x88u);XCTAssertEqual(f.read("SAVE.DSK").size(),161024u);
XCTAssertEqual(f.read("SAVE.DSK")[0],0x33u);
s.setWriteProtected(true);XCTAssertTrue(s.snapshot().writeProtected);
bool rejected=false;try{s.setWriteProtected(false);}catch(const std::runtime_error&){rejected=true;}
XCTAssertTrue(rejected);XCTAssertTrue(s.snapshot().writeProtected);
s.mount(0,"SAVE.DSK");s.setWriteProtected(false);write();XCTAssertEqual(p.r(0x48),0u);
XCTAssertEqual(f.read("SAVE.DSK")[0],0x99u);XCTAssertEqual(s.snapshot().drives[0].writes,1u);
}
- (void)testDirectoryPagesFATRecordsAndCurrentDirectory {
CardFixture f;std::filesystem::create_directory(f.folder/"Games");
for(unsigned i=0;i<18;++i)f.file("F"+std::to_string(i)+".DSK",std::vector<std::uint8_t>(161280));
f.text("Long invisible file.txt","not an 8.3 name");
SDCDevice s({},f.folder.string());Wire p{s};p.mode();
p.command(0xc0,'>'<<16);XCTAssertEqual(p.r(0x48),0x90u);
XCTAssertEqual(p.extended("L:*.*"),0u);p.command(0xc0,'>'<<16);auto first=p.read(256);
XCTAssertEqual(first[0],'F');XCTAssertEqual(first[12],0u);XCTAssertEqual(first[13],2u);XCTAssertEqual(first[14],0x76u);
p.command(0xc0,'>'<<16);auto last=p.read(256);XCTAssertEqual(last[48],0u);
XCTAssertEqual(p.extended("D:games"),0u);XCTAssertTrue(s.snapshot().currentDirectory=="/games");
p.command(0xc0,'C'<<16);auto leaf=p.read(256);XCTAssertEqual(leaf[0],'G');XCTAssertEqual(leaf[32],0u);
XCTAssertEqual(p.extended("D:.."),0u);p.command(0xc0,'C'<<16);
// Explorer terminates its parent walk only on immediate FAILED. Returning
// a READY block here makes its receive routine clear carry and loop.
XCTAssertEqual(p.r(0x48),0x90u);XCTAssertEqual(p.r(0x4a),0u);XCTAssertEqual(p.r(0x4b),0u);
XCTAssertEqual(p.extended("M:F0.DSK"),0u);p.command(0xc0,'I'<<16);auto info=p.read(256);
XCTAssertEqual(info[28],0u);XCTAssertEqual(info[29],0x76u);XCTAssertEqual(info[30],2u);
}
- (void)testNumberedSetsStartupAndTransactionalMountFailure {
CardFixture f;std::filesystem::create_directory(f.folder/"SET");
f.file("SET/DISK1.DSK",std::vector<std::uint8_t>(161280,1));f.file("SET/DISK3.DSK",std::vector<std::uint8_t>(161280,3));
f.text("STARTUP.CFG","D=SET\r\n0=/SET\r\n");
SDCDevice s({},f.folder.string());XCTAssertTrue(s.snapshot().drives[0].name=="/SET/DISK1.DSK");
Wire p{s};p.mode();p.command(0xc0,'+'<<16);XCTAssertTrue(s.snapshot().drives[0].name=="/SET/DISK3.DSK");
p.command(0xd0,('#'<<16)|(1<<8));XCTAssertTrue(s.snapshot().drives[0].name=="/SET/DISK1.DSK");
p.command(0xd0,('#'<<16)|(2<<8));XCTAssertEqual(p.r(0x48),0x90u);
XCTAssertTrue(s.snapshot().drives[0].name=="/SET/DISK1.DSK");
XCTAssertEqual(p.extended("M:NOTHERE.DSK"),0x90u);XCTAssertTrue(s.snapshot().drives[0].mounted);
p.command(0x80,0);p.read(256);s.reset();XCTAssertEqual(s.snapshot().drives[0].reads,1u);
XCTAssertTrue(s.snapshot().drives[0].name=="/SET/DISK1.DSK");
}
- (void)testRootConfinementSymlinksAndDirectoryMutationGuards {
CardFixture card,outside;outside.file("SECRET.DSK",std::vector<std::uint8_t>(161280,0x5a));
std::filesystem::create_symlink(outside.folder/"SECRET.DSK",card.folder/"LINK.DSK");
std::filesystem::create_directory_symlink(outside.folder,card.folder/"OUTSIDE");
card.file("LOCAL.DSK",std::vector<std::uint8_t>(161280,0));
SDCDevice s({},card.folder.string(),false);Wire p{s};p.mode();
XCTAssertTrue(p.extended("M:../SECRET.DSK")&0x80);XCTAssertTrue(p.extended("M:LINK.DSK")&0x80);
XCTAssertTrue(p.extended("D:OUTSIDE")&0x80);XCTAssertTrue(p.extended("N:OUTSIDE/NEW.DSK")&0x80);
XCTAssertTrue(p.extended("X:LINK.DSK")&0x80);XCTAssertTrue(std::filesystem::exists(outside.folder/"SECRET.DSK"));
XCTAssertEqual(p.extended("M:LOCAL.DSK"),0u);XCTAssertEqual(p.extended("X:LOCAL.DSK"),0xa0u);
std::filesystem::create_hard_link(card.folder/"LOCAL.DSK",card.folder/"ALIAS.DSK");
XCTAssertEqual(p.extended("M:ALIAS.DSK",1),0xa0u);
s.eject(0);XCTAssertEqual(p.extended("K:NEW"),0u);XCTAssertEqual(p.extended("D:NEW"),0u);
XCTAssertEqual(p.extended("X:/NEW"),0xa0u);XCTAssertEqual(p.extended("D:/"),0u);XCTAssertEqual(p.extended("X:NEW"),0u);
XCTAssertEqual(outside.read("SECRET.DSK")[0],0x5au);
}
- (void)testNewImageRenameNoClobberAndReadOnlyFolderCommands {
CardFixture f;SDCDevice s({},f.folder.string());Wire p{s};p.mode();
XCTAssertEqual(p.extended("N:NEW.DSK"),0xc0u);s.setWriteProtected(false);
XCTAssertEqual(p.extended("N:NEW.DSK"),0u);XCTAssertEqual(f.read("NEW.DSK").size(),161280u);
XCTAssertEqual(p.extended("N:NEW.DSK"),0u); // existing image is mounted, not overwritten
s.eject(0);f.text("OTHER.DSK","preserve");
std::string rename="R:NEW.DSK";rename.push_back(0);rename+="OTHER.DSK";
XCTAssertEqual(p.extended(rename),0xa0u);XCTAssertEqual(f.read("OTHER.DSK").size(),8u);
rename="R:NEW.DSK";rename.push_back(0);rename+="RENAMED.DSK";
XCTAssertEqual(p.extended(rename),0u);XCTAssertTrue(std::filesystem::exists(f.folder/"RENAMED.DSK"));
s.setWriteProtected(true);XCTAssertEqual(p.extended("X:RENAMED.DSK"),0xc0u);
XCTAssertEqual(p.extended("K:DIR"),0xc0u);
}
- (void)testJVCVDKGeometryAndFloppyCompatibility {
CardFixture f;std::vector<std::uint8_t> jvc(4+36*256,0);jvc[0]=18;jvc[1]=2;jvc[2]=1;jvc[3]=1;
std::fill_n(jvc.begin()+4+18*256,256,0x33);f.file("TWO.DSK",jvc);
// One extra track makes the adjusted single-side LSN18 ->36 valid.
jvc.resize(4+54*256);std::fill_n(jvc.begin()+4+36*256,256,0x77);f.file("TWO.DSK",jvc);
SDCDevice s({},f.folder.string());s.mount(0,"TWO.DSK");Wire p{s};p.mode();
p.command(0x82,18);auto data=p.read(256);XCTAssertEqual(data[0],0x77u);
p.command(0x80,18);data=p.read(256);XCTAssertEqual(data[0],0x33u);
p.w(0x40,0);p.w(0x40,1);p.w(0x49,1);p.w(0x4a,1);p.w(0x48,0x80);
XCTAssertEqual(p.r(0x48),3u);for(unsigned i=0;i<256;++i)XCTAssertEqual(p.r(0x4b),0x77u);
XCTAssertEqual(p.r(0x48),0u);XCTAssertEqual(p.host.nmis,1u);
std::vector<std::uint8_t> vdk(12+161280,0);vdk[0]='d';vdk[1]='k';vdk[2]=12;vdk[8]=35;vdk[9]=1;vdk[10]=1;
f.file("LOCK.VDK",vdk);s.mount(0,"LOCK.VDK");s.setWriteProtected(false);
XCTAssertTrue(s.snapshot().drives[0].writeProtected);
}
- (void)testMalformedCommandsAndImagesAreBoundedAndRecoverable {
CardFixture f;f.file("BAD.SDF",std::vector<std::uint8_t>(256,0));
f.text("BAD.SDF","SDF1"+std::string(252,'\0'));
SDCDevice s({},f.folder.string());Wire p{s};p.mode();XCTAssertEqual(p.extended("M:BAD.SDF"),0x84u);
p.command(0xe0);for(unsigned i=0;i<256;++i)p.w(0x4a+(i&1),'X');XCTAssertEqual(p.r(0x48),0x84u);
p.command(0xf0);XCTAssertEqual(p.r(0x48),0x84u);
XCTAssertEqual(p.extended("L:*.*"),0u);XCTAssertTrue(s.snapshot().error.empty());
SDCDevice missing({},"");Wire q{missing};q.mode();XCTAssertEqual(q.extended("M:NO.DSK"),0x90u);
bool rejected=false;try{SDCDevice bad({},(f.folder/"MISSING").string());}catch(const std::invalid_argument&){rejected=true;}
XCTAssertTrue(rejected);
}
@end