Files
Triforce-Source/tests/png_publication_test.cpp
ruckus7382sfgsgdf 34b3683441 Triforce v0.2.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 19:32:48 -06:00

137 lines
7.3 KiB
C++

#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <atomic>
#include <cerrno>
#include <cstdarg>
#include <condition_variable>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
static void need(bool ok,const char* why){if(!ok){std::fprintf(stderr,"FAIL: %s\n",why);std::exit(1);}}
std::mutex mu;
std::map<std::string,std::vector<uint8_t>> files;
struct Stream{std::string path;};
std::map<FILE*,std::unique_ptr<Stream>> live;
std::vector<std::string> messages;
std::string mode;
unsigned writes=0,closes=0,fail_write=0;
const std::vector<uint8_t> previous={'p','r','e','v','i','o','u','s'};
void logf(const char* format,...){char text[2048];va_list args;va_start(args,format);std::vsnprintf(text,sizeof text,format,args);va_end(args);std::lock_guard lk(mu);messages.emplace_back(text);}
FILE* png_open(const char* name,const char* access){
std::lock_guard lk(mu);
if(mode=="open-failure"){errno=EACCES;return nullptr;}
if(std::strchr(access,'x') && files.count(name)){errno=EEXIST;return nullptr;}
files[name].clear();auto s=std::make_unique<Stream>();s->path=name;
FILE* f=reinterpret_cast<FILE*>(s.get());live.emplace(f,std::move(s));return f;
}
size_t png_write(const void* data,size_t size,size_t count,FILE* f){
std::lock_guard lk(mu);auto& out=files.at(live.at(f)->path);writes++;
const bool fail=(fail_write && writes==fail_write);
size_t n=size*count;if(fail && n)n--;
auto p=static_cast<const uint8_t*>(data);out.insert(out.end(),p,p+n);
if(fail){errno=ENOSPC;return size?n/size:0;}return count;
}
int png_close(FILE* f){std::lock_guard lk(mu);need(live.erase(f)==1,"exactly one close per owned stream");closes++;if(mode=="close-failure"){errno=ENOSPC;return EOF;}return 0;}
int png_remove(const char* path){std::lock_guard lk(mu);if(mode=="cleanup-failure"){errno=EACCES;return -1;}if(!files.erase(path)){errno=ENOENT;return -1;}return 0;}
int png_rename(const char* from,const char* to){
std::lock_guard lk(mu);if(mode=="publish-failure"){errno=EACCES;return -1;}
files[to]=std::move(files.at(from));files.erase(from);return 0;
}
[[maybe_unused]] int png_move(const char* from,const char* to,unsigned){return png_rename(from,to)==0;}
[[maybe_unused]] unsigned png_last_error(){return 5;}
#ifndef MOVEFILE_REPLACE_EXISTING
#define MOVEFILE_REPLACE_EXISTING 1
#endif
#define fopen png_open
#define fwrite png_write
#define fclose png_close
#define remove png_remove
#define rename png_rename
#define MoveFileExA png_move
#define GetLastError png_last_error
/* PNG */
#undef fopen
#undef fwrite
#undef fclose
#undef remove
#undef rename
#undef MoveFileExA
#undef GetLastError
const uint32_t kShotW=257,kShotH=251;
/* ANNOUNCE */
static std::vector<uint8_t> pixels(unsigned seed){
std::vector<uint8_t> out(size_t(kShotW)*kShotH*4);
for(size_t i=0;i<out.size();i+=4){out[i]=uint8_t(seed);out[i+1]=73;out[i+2]=211;out[i+3]=127;}
return out;
}
static bool saved(const std::string& path,unsigned seed){auto rgba=pixels(seed);return write_png(path.c_str(),rgba.data(),kShotW,kShotH);}
static void emit(const char* directory){
unsigned n=0;
for(auto& [name,data]:files)if(name.ends_with(".png") && data!=previous){
const std::string path=std::string(directory)+"/"+std::to_string(n++)+".png";
FILE* f=std::fopen(path.c_str(),"wb");need(f!=nullptr,"fixture output open");need(std::fwrite(data.data(),1,data.size(),f)==data.size(),"fixture output write");need(std::fclose(f)==0,"fixture output close");
}
}
int main(int argc,char**argv){
need(argc==3,"mode/output directory");mode=argv[1];const std::string target="capture.png";files[target]=previous;
if(mode.starts_with("write-"))fail_write=unsigned(std::atoi(mode.c_str()+6));
if(mode=="cleanup-failure" || mode=="announce-failure")fail_write=1;
if(mode=="bounded-report"){
mode="open-failure";for(int i=0;i<30;i++)need(!saved(target,17),"every failed capture returns false");
need(!messages.empty() && messages.size()<=8,"failure diagnostics remain bounded");
need(files[target]==previous && live.empty(),"repeated failure preserves prior capture and handles");
mode="healthy";need(saved(target,19),"capture still recovers after report limit");emit(argv[2]);return 0;
}
if(mode=="invalid"){
uint8_t one[4]{};
need(!write_png(target.c_str(),one,0,1),"zero width rejected");
need(!write_png(target.c_str(),one,UINT32_MAX,1),"PNG width limit rejected");
need(!write_png(target.c_str(),one,1000000,1000000),"oversized IDAT rejected before source access");
need(!write_png(nullptr,one,1,1) && !write_png("",one,1,1) && !write_png(target.c_str(),nullptr,1,1),"missing input/path rejected");
need(files.size()==1 && files[target]==previous && !writes && !closes,"invalid input leaves destination untouched");return 0;
}
if(mode=="parallel" || mode=="same-target"){
std::atomic<unsigned> ready{0};std::atomic<bool> go{false};std::vector<std::thread> workers;
for(unsigned i=1;i<=12;i++)workers.emplace_back([&,i]{ready++;while(!go.load())std::this_thread::yield();need(saved(mode=="same-target"?target:std::to_string(i)+".png",i),"concurrent capture succeeds");});
while(ready.load()!=12)std::this_thread::yield();
go=true;
for(auto& t:workers)t.join();
need(live.empty(),"parallel files all closed");emit(argv[2]);return 0;
}
if(mode=="collisions" || mode=="collision-limit"){
unsigned count=mode=="collisions"?3:128;
for(unsigned i=0;i<count;i++)files[target+".part."+std::to_string(i)]=previous;
bool ok=saved(target,17);need(ok==(mode=="collisions"),"bounded exclusive creation");
for(unsigned i=0;i<count;i++)need(files[target+".part."+std::to_string(i)]==previous,"foreign collision preserved");
if(!ok){need(files[target]==previous,"collision failure preserves target");mode="healthy";need(saved(target,19),"next capture retries after collisions");}
emit(argv[2]);return 0;
}
if(mode=="announce-failure" || mode=="announce-success"){
auto px=std::make_shared<std::vector<uint8_t>>(pixels(17));announce(px,target,1);
bool success=mode=="announce-success";
unsigned said=0;for(auto& m:messages)said+=m.find("written to")!=std::string::npos;
need(said==(success?1u:0u),"success announcement matches actual publication");
need(success || files[target]==previous,"failed announced capture preserves target");emit(argv[2]);return 0;
}
const bool healthy=mode=="healthy";
bool ok=saved(target,17);need(ok==healthy,"publication status reflects write/close/replace result");
need(live.empty(),"all file handles closed on success and failure");
if(!healthy){
need(files[target]==previous,"failed capture preserves previous complete file");
need(!messages.empty() && messages.back().find("capture.png")!=std::string::npos,"failure identifies capture path");
need(files.size()==(mode=="cleanup-failure"?2u:1u),"only owned incomplete temporary may remain on cleanup failure");
if(mode=="cleanup-failure")return 0;
mode="healthy";fail_write=0;need(saved(target,19),"subsequent capture recovers without disabling output");
}
emit(argv[2]);return 0;
}