a5c7fc6ad9
The check was actually half-broken from the beginning and until df83ee4; the thick red line was rendered properly but the error text was rendered with width 0, which by chance worked on some GL implementations. That commit has fixed the underlying bug but left the text line width at 0 to avoid test breakage. This commit fixes the bug, turns off the check completely, and updates the tests to account for breakage.
361 lines
12 KiB
C++
361 lines
12 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Our harness for running test cases, and reusable checks.
|
|
//
|
|
// Copyright 2016 whitequark
|
|
//-----------------------------------------------------------------------------
|
|
#include "harness.h"
|
|
#include <regex>
|
|
#include <cairo.h>
|
|
#if defined(WIN32)
|
|
#include <windows.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
namespace SolveSpace {
|
|
// These are defined in headless.cpp, and aren't exposed in solvespace.h.
|
|
extern std::string resourceDir;
|
|
extern std::vector<std::string> fontFiles;
|
|
extern bool antialias;
|
|
extern std::shared_ptr<Pixmap> framebuffer;
|
|
}
|
|
|
|
// The paths in __FILE__ are from the build system, but defined(WIN32) returns
|
|
// the value for the host system.
|
|
#define BUILD_PATH_SEP (__FILE__[0]=='/' ? '/' : '\\')
|
|
#define HOST_PATH_SEP PATH_SEP
|
|
|
|
static std::string BuildRoot() {
|
|
static std::string rootDir;
|
|
if(!rootDir.empty()) return rootDir;
|
|
|
|
rootDir = __FILE__;
|
|
rootDir.erase(rootDir.rfind(BUILD_PATH_SEP) + 1);
|
|
return rootDir;
|
|
}
|
|
|
|
static std::string HostRoot() {
|
|
static std::string rootDir;
|
|
if(!rootDir.empty()) return rootDir;
|
|
|
|
// No especially good way to do this, so let's assume somewhere up from
|
|
// the current directory there's our repository, with CMakeLists.txt, and
|
|
// pivot from there.
|
|
#if defined(WIN32)
|
|
wchar_t currentDirW[MAX_PATH];
|
|
GetCurrentDirectoryW(MAX_PATH, currentDirW);
|
|
rootDir = Narrow(currentDirW);
|
|
#else
|
|
rootDir = ".";
|
|
#endif
|
|
|
|
// We're never more than four levels deep.
|
|
for(size_t i = 0; i < 4; i++) {
|
|
std::string listsPath = rootDir;
|
|
listsPath += HOST_PATH_SEP;
|
|
listsPath += "CMakeLists.txt";
|
|
FILE *f = ssfopen(listsPath, "r");
|
|
if(f) {
|
|
fclose(f);
|
|
rootDir += HOST_PATH_SEP;
|
|
rootDir += "test";
|
|
return rootDir;
|
|
}
|
|
|
|
if(rootDir[0] == '.') {
|
|
rootDir += HOST_PATH_SEP;
|
|
rootDir += "..";
|
|
} else {
|
|
rootDir.erase(rootDir.rfind(HOST_PATH_SEP));
|
|
}
|
|
}
|
|
|
|
ssassert(false, "Couldn't locate repository root");
|
|
}
|
|
|
|
enum class Color {
|
|
Red,
|
|
Green,
|
|
DarkGreen
|
|
};
|
|
|
|
static std::string Colorize(Color color, std::string input) {
|
|
#if !defined(WIN32)
|
|
if(isatty(fileno(stdout))) {
|
|
switch(color) {
|
|
case Color::Red:
|
|
return "\e[1;31m" + input + "\e[0m";
|
|
case Color::Green:
|
|
return "\e[1;32m" + input + "\e[0m";
|
|
case Color::DarkGreen:
|
|
return "\e[36m" + input + "\e[0m";
|
|
}
|
|
}
|
|
#endif
|
|
return input;
|
|
}
|
|
|
|
// Normalizes a savefile. Different platforms have slightly different floating-point
|
|
// behavior, so if we want to compare savefiles byte-by-byte, we need to do something
|
|
// to get rid of irrelevant differences in LSB.
|
|
static std::string PrepareSavefile(std::string data) {
|
|
// Round everything to 2**30 ~ 1e9
|
|
const double precision = pow(2, 30);
|
|
|
|
size_t newline = 0;
|
|
while(newline < std::string::npos) {
|
|
size_t nextNewline = data.find('\n', newline + 1);
|
|
|
|
size_t eqPos = data.find('=', newline + 1);
|
|
if(eqPos < nextNewline) {
|
|
std::string key = data.substr(newline + 1, eqPos - newline - 1),
|
|
value = data.substr(eqPos + 1, nextNewline - eqPos - 1);
|
|
for(int i = 0; SolveSpaceUI::SAVED[i].type != 0; i++) {
|
|
if(SolveSpaceUI::SAVED[i].desc != key) continue;
|
|
if(SolveSpaceUI::SAVED[i].fmt != 'f') continue;
|
|
double f = strtod(value.c_str(), NULL);
|
|
f = round(f * precision) / precision;
|
|
std::string newValue = ssprintf("%.20f", f);
|
|
ssassert(value.size() == newValue.size(), "Expected no change in value length");
|
|
std::copy(newValue.begin(), newValue.end(),
|
|
data.begin() + eqPos + 1);
|
|
}
|
|
}
|
|
|
|
size_t spPos = data.find(' ', newline + 1);
|
|
if(spPos < nextNewline) {
|
|
std::string cmd = data.substr(newline + 1, spPos - newline - 1);
|
|
if(cmd == "Surface" || cmd == "SCtrl" || cmd == "TrimBy" || cmd == "AddSurface" ||
|
|
cmd == "Curve" || cmd == "CCtrl" || cmd == "CurvePt" || cmd == "AddCurve") {
|
|
data.replace(newline + 1, nextNewline, nextNewline - newline - 1, ' ');
|
|
}
|
|
}
|
|
|
|
newline = nextNewline;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
bool Test::Helper::RecordCheck(bool success) {
|
|
checkCount++;
|
|
if(!success) failCount++;
|
|
return success;
|
|
}
|
|
|
|
void Test::Helper::PrintFailure(const char *file, int line, std::string msg) {
|
|
std::string shortFile = file;
|
|
shortFile.erase(0, BuildRoot().size());
|
|
fprintf(stderr, "test%c%s:%d: FAILED: %s\n",
|
|
BUILD_PATH_SEP, shortFile.c_str(), line, msg.c_str());
|
|
}
|
|
|
|
std::string Test::Helper::GetAssetPath(std::string testFile, std::string assetName,
|
|
std::string mangle) {
|
|
if(!mangle.empty()) {
|
|
assetName.insert(assetName.rfind('.'), "." + mangle);
|
|
}
|
|
testFile.erase(0, BuildRoot().size());
|
|
testFile.erase(testFile.rfind(BUILD_PATH_SEP) + 1);
|
|
return PathSepUnixToPlatform(HostRoot() + "/" + testFile + assetName);
|
|
}
|
|
|
|
bool Test::Helper::CheckTrue(const char *file, int line, const char *expr, bool result) {
|
|
if(!RecordCheck(result)) {
|
|
PrintFailure(file, line,
|
|
ssprintf("(%s) == %s", expr, result ? "true" : "false"));
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool Test::Helper::CheckLoad(const char *file, int line, const char *fixture) {
|
|
std::string fixturePath = GetAssetPath(file, fixture);
|
|
|
|
FILE *f = ssfopen(fixturePath.c_str(), "rb");
|
|
bool fixtureExists = (f != NULL);
|
|
if(f) fclose(f);
|
|
|
|
bool result = fixtureExists &&
|
|
SS.LoadFromFile(fixturePath) && SS.ReloadAllImported(/*canCancel=*/false);
|
|
if(!RecordCheck(result)) {
|
|
PrintFailure(file, line,
|
|
ssprintf("loading file '%s'", fixturePath.c_str()));
|
|
return false;
|
|
} else {
|
|
SS.AfterNewFile();
|
|
SS.GW.offset = {};
|
|
SS.GW.scale = 10.0;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool Test::Helper::CheckSave(const char *file, int line, const char *reference) {
|
|
std::string refPath = GetAssetPath(file, reference),
|
|
outPath = GetAssetPath(file, reference, "out");
|
|
if(!RecordCheck(SS.SaveToFile(outPath))) {
|
|
PrintFailure(file, line,
|
|
ssprintf("saving file '%s'", refPath.c_str()));
|
|
return false;
|
|
} else {
|
|
std::string refData, outData;
|
|
ReadFile(refPath, &refData);
|
|
ReadFile(outPath, &outData);
|
|
if(!RecordCheck(PrepareSavefile(refData) == PrepareSavefile(outData))) {
|
|
PrintFailure(file, line, "savefile doesn't match reference");
|
|
return false;
|
|
}
|
|
|
|
ssremove(outPath);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool Test::Helper::CheckRender(const char *file, int line, const char *reference) {
|
|
PaintGraphics();
|
|
|
|
std::string refPath = GetAssetPath(file, reference),
|
|
outPath = GetAssetPath(file, reference, "out"),
|
|
diffPath = GetAssetPath(file, reference, "diff");
|
|
|
|
std::shared_ptr<Pixmap> refPixmap = Pixmap::ReadPng(refPath.c_str(), /*flip=*/true);
|
|
if(!RecordCheck(refPixmap && refPixmap->Equals(*framebuffer))) {
|
|
framebuffer->WritePng(outPath.c_str(), /*flip=*/true);
|
|
|
|
if(!refPixmap) {
|
|
PrintFailure(file, line, "reference render not present");
|
|
return false;
|
|
}
|
|
|
|
ssassert(refPixmap->format == framebuffer->format, "Expected buffer formats to match");
|
|
if(refPixmap->width != framebuffer->width ||
|
|
refPixmap->height != framebuffer->height) {
|
|
PrintFailure(file, line, "render doesn't match reference; dimensions differ");
|
|
} else {
|
|
std::shared_ptr<Pixmap> diffPixmap =
|
|
Pixmap::Create(refPixmap->format, refPixmap->width, refPixmap->height);
|
|
|
|
int diffPixelCount = 0;
|
|
for(size_t j = 0; j < refPixmap->height; j++) {
|
|
for(size_t i = 0; i < refPixmap->width; i++) {
|
|
if(!refPixmap->GetPixel(i, j).Equals(framebuffer->GetPixel(i, j))) {
|
|
diffPixelCount++;
|
|
diffPixmap->SetPixel(i, j, RgbaColor::From(255, 0, 0, 255));
|
|
}
|
|
}
|
|
}
|
|
|
|
diffPixmap->WritePng(diffPath.c_str(), /*flip=*/true);
|
|
std::string message =
|
|
ssprintf("render doesn't match reference; %d (%.2f%%) pixels differ",
|
|
diffPixelCount,
|
|
100.0 * diffPixelCount / (refPixmap->width * refPixmap->height));
|
|
PrintFailure(file, line, message);
|
|
}
|
|
return false;
|
|
} else {
|
|
ssremove(outPath);
|
|
ssremove(diffPath);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Avoid global constructors; using a global static vector instead of a local one
|
|
// breaks MinGW for some obscure reason.
|
|
static std::vector<Test::Case> *testCasesPtr;
|
|
int Test::Case::Register(Test::Case testCase) {
|
|
static std::vector<Test::Case> testCases;
|
|
testCases.push_back(testCase);
|
|
testCasesPtr = &testCases;
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
#if defined(_MSC_VER)
|
|
_set_abort_behavior(0, _WRITE_ABORT_MSG);
|
|
#endif
|
|
#if defined(WIN32)
|
|
InitHeaps();
|
|
#endif
|
|
|
|
std::regex filter(".*");
|
|
if(argc == 1) {
|
|
} else if(argc == 2) {
|
|
filter = argv[1];
|
|
} else {
|
|
fprintf(stderr, "Usage: %s [test filter regex]\n", argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
resourceDir = HostRoot();
|
|
resourceDir.erase(resourceDir.rfind(HOST_PATH_SEP) + 1);
|
|
resourceDir += "res";
|
|
|
|
fontFiles.push_back(HostRoot() + HOST_PATH_SEP + "Gentium-R.ttf");
|
|
|
|
// Different Cairo versions have different antialiasing algorithms.
|
|
antialias = false;
|
|
|
|
// Wreck order dependencies between tests!
|
|
std::random_shuffle(testCasesPtr->begin(), testCasesPtr->end());
|
|
|
|
auto testStartTime = std::chrono::steady_clock::now();
|
|
size_t ranTally = 0, skippedTally = 0, checkTally = 0, failTally = 0;
|
|
for(Test::Case &testCase : *testCasesPtr) {
|
|
std::string testCaseName = testCase.fileName;
|
|
testCaseName.erase(0, BuildRoot().size());
|
|
testCaseName.erase(testCaseName.rfind(BUILD_PATH_SEP));
|
|
testCaseName += BUILD_PATH_SEP + testCase.caseName;
|
|
|
|
std::smatch filterMatch;
|
|
if(!std::regex_search(testCaseName, filterMatch, filter)) {
|
|
skippedTally += 1;
|
|
continue;
|
|
}
|
|
|
|
SS.Init();
|
|
SS.checkClosedContour = false;
|
|
|
|
Test::Helper helper = {};
|
|
testCase.fn(&helper);
|
|
|
|
SK.Clear();
|
|
SS.Clear();
|
|
|
|
ranTally += 1;
|
|
checkTally += helper.checkCount;
|
|
failTally += helper.failCount;
|
|
if(helper.checkCount == 0) {
|
|
fprintf(stderr, " %s test %s (empty)\n",
|
|
Colorize(Color::Red, "??").c_str(),
|
|
Colorize(Color::DarkGreen, testCaseName).c_str());
|
|
} else if(helper.failCount > 0) {
|
|
fprintf(stderr, " %s test %s\n",
|
|
Colorize(Color::Red, "NG").c_str(),
|
|
Colorize(Color::DarkGreen, testCaseName).c_str());
|
|
} else {
|
|
fprintf(stderr, " %s test %s\n",
|
|
Colorize(Color::Green, "OK").c_str(),
|
|
Colorize(Color::DarkGreen, testCaseName).c_str());
|
|
}
|
|
}
|
|
|
|
auto testEndTime = std::chrono::steady_clock::now();
|
|
std::chrono::duration<double> testTime = testEndTime - testStartTime;
|
|
|
|
if(failTally > 0) {
|
|
fprintf(stderr, "Failure! %u checks failed\n",
|
|
(unsigned)failTally);
|
|
} else {
|
|
fprintf(stderr, "Success! %u test cases (%u skipped), %u checks, %.3fs\n",
|
|
(unsigned)ranTally, (unsigned)skippedTally,
|
|
(unsigned)checkTally, testTime.count());
|
|
}
|
|
|
|
// At last, try to reset all caches we or our dependencies have, to make SNR
|
|
// of memory checking tools like valgrind higher.
|
|
cairo_debug_reset_static_data();
|
|
|
|
return (failTally > 0);
|
|
}
|