367 lines
16 KiB
C++
367 lines
16 KiB
C++
#include <chrono>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
#include <destrum/Assets/PackFile.h>
|
|
|
|
#include "TestUtils.h"
|
|
|
|
using namespace test;
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace {
|
|
struct CookDirs {
|
|
fs::path root;
|
|
fs::path input;
|
|
fs::path output;
|
|
};
|
|
|
|
CookDirs makeDirs(const char* name)
|
|
{
|
|
CookDirs dirs;
|
|
dirs.root = fs::temp_directory_path() / name;
|
|
fs::remove_all(dirs.root);
|
|
dirs.input = dirs.root / "src";
|
|
dirs.output = dirs.root / "out";
|
|
fs::create_directories(dirs.input);
|
|
return dirs;
|
|
}
|
|
|
|
void writeText(const fs::path& path, const std::string& text)
|
|
{
|
|
fs::create_directories(path.parent_path());
|
|
std::ofstream{path, std::ios::binary} << text;
|
|
}
|
|
|
|
// 2x2 uncompressed 32 bit TGA, top left origin
|
|
void writeTga(const fs::path& path)
|
|
{
|
|
const std::uint8_t header[18] = {0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 32, 0x28};
|
|
fs::create_directories(path.parent_path());
|
|
std::ofstream file(path, std::ios::binary);
|
|
file.write(reinterpret_cast<const char*>(header), sizeof(header));
|
|
for (int i = 0; i < 4; ++i) {
|
|
const std::uint8_t bgra[4] = {0, 0, 255, 255};
|
|
file.write(reinterpret_cast<const char*>(bgra), sizeof(bgra));
|
|
}
|
|
}
|
|
|
|
int runChefArgs(const CookDirs& dirs, const std::string& args)
|
|
{
|
|
const fs::path log = dirs.root / "chef.log";
|
|
std::string command = "\"" + std::string(DESTRUM_THECHEF_PATH) + "\" " + args + " > \"" + log.string() +
|
|
"\" 2>&1";
|
|
#ifdef _WIN32
|
|
// cmd.exe strips the outer quotes, the inner ones keep paths with spaces intact
|
|
command = "\"" + command + "\"";
|
|
#endif
|
|
return std::system(command.c_str());
|
|
}
|
|
|
|
int runChef(const CookDirs& dirs, const std::string& flags = {})
|
|
{
|
|
return runChefArgs(dirs, "--input \"" + dirs.input.string() + "\" --output \"" + dirs.output.string() + "\" " + flags);
|
|
}
|
|
|
|
void expectChef(const CookDirs& dirs, const std::string& flags, bool succeeds, const char* message)
|
|
{
|
|
if ((runChef(dirs, flags) == 0) != succeeds) {
|
|
std::cerr << readFile(dirs.root / "chef.log") << '\n';
|
|
check(false, message);
|
|
}
|
|
}
|
|
|
|
nlohmann::json readManifest(const CookDirs& dirs)
|
|
{
|
|
return nlohmann::json::parse(readFile(dirs.output / "manifest.json"));
|
|
}
|
|
|
|
const nlohmann::json* findEntry(const nlohmann::json& manifest, const std::string& src)
|
|
{
|
|
for (const auto& entry : manifest["assets"]) {
|
|
if (entry["src"] == src) {
|
|
return &entry;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Puts the output well before its dependency, so the next cook has to rebuild it without sleeping
|
|
fs::file_time_type makeStale(const fs::path& output, const fs::path& dependency)
|
|
{
|
|
const auto stale = fs::last_write_time(dependency) - std::chrono::hours{1};
|
|
fs::last_write_time(output, stale);
|
|
return stale;
|
|
}
|
|
|
|
bool hasTempFiles(const fs::path& dir)
|
|
{
|
|
for (const auto& entry : fs::recursive_directory_iterator(dir)) {
|
|
if (entry.path().extension() == ".tmp") {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void writeShaders(const CookDirs& dirs)
|
|
{
|
|
writeText(dirs.input / "shaders" / "include" / "common.glsl", "vec4 tint() { return vec4(1.0); }\n");
|
|
writeText(dirs.input / "shaders" / "plain.frag",
|
|
"#version 450\n"
|
|
"#extension GL_GOOGLE_include_directive : require\n"
|
|
"#include \"common.glsl\"\n"
|
|
"layout(location = 0) out vec4 color;\n"
|
|
"void main() { color = tint(); }\n");
|
|
}
|
|
|
|
void writeModel(const CookDirs& dirs)
|
|
{
|
|
writeText(dirs.input / "models" / "tri.obj",
|
|
"mtllib tri.mtl\n"
|
|
"v 0 0 0\nv 1 0 0\nv 0 1 0\n"
|
|
"vt 0 0\nvt 1 0\nvt 0 1\n"
|
|
"vn 0 0 1\n"
|
|
"usemtl red\n"
|
|
"f 1/1/1 2/2/1 3/3/1\n");
|
|
writeText(dirs.input / "models" / "tri.mtl", "newmtl red\nKd 1 0 0\n");
|
|
}
|
|
|
|
void testCookRecordsEveryOutput()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_outputs");
|
|
writeShaders(dirs);
|
|
writeModel(dirs);
|
|
writeTga(dirs.input / "textures" / "red.tga");
|
|
writeText(dirs.input / "data" / "notes.txt", "hello");
|
|
|
|
expectChef(dirs, "", true, "a clean cook must succeed");
|
|
|
|
check(fs::exists(dirs.output / "shaders" / "plain.frag.spv"), "entry shaders compile to SPIR-V");
|
|
check(fs::exists(dirs.output / "models" / "tri.obj.dmodel"), "models cook to .dmodel");
|
|
check(fs::exists(dirs.output / "models" / "tri.obj"), "source models are still copied");
|
|
check(fs::exists(dirs.output / "textures" / "red.tga.dtex"), "LDR images cook to .dtex");
|
|
check(readFile(dirs.output / "data" / "notes.txt") == "hello", "unknown files are copied");
|
|
check(!hasTempFiles(dirs.output), "a finished cook leaves no temporary files");
|
|
|
|
const auto manifest = readManifest(dirs);
|
|
const auto* shader = findEntry(manifest, "shaders/plain.frag");
|
|
check(shader && (*shader)["deps"] == nlohmann::json::array({"shaders/include/common.glsl"}),
|
|
"shader includes are recorded as dependencies");
|
|
const auto* model = findEntry(manifest, "models/tri.obj");
|
|
check(model && (*model)["out"] == "models/tri.obj.dmodel", "the cooked model is the primary output");
|
|
check(model && (*model)["outputs"].size() == 2, "a model owns its copy and its cooked file");
|
|
check(model && (*model)["deps"] == nlohmann::json::array({"models/tri.mtl"}),
|
|
".obj material libraries are recorded as dependencies");
|
|
check(findEntry(manifest, "shaders/include/common.glsl") != nullptr, "includes are listed too");
|
|
|
|
expectChef(dirs, "--validate --strict", true, "a fresh cook must validate");
|
|
}
|
|
|
|
void testUnchangedSourcesAreSkipped()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_unchanged");
|
|
writeShaders(dirs);
|
|
writeModel(dirs);
|
|
writeTga(dirs.input / "red.tga");
|
|
expectChef(dirs, "", true, "the first cook must succeed");
|
|
|
|
const std::vector<fs::path> outputs = {
|
|
dirs.output / "shaders" / "plain.frag.spv",
|
|
dirs.output / "models" / "tri.obj.dmodel",
|
|
dirs.output / "red.tga.dtex",
|
|
dirs.output / "red.tga",
|
|
};
|
|
std::vector<fs::file_time_type> times;
|
|
for (const auto& output : outputs) {
|
|
times.push_back(fs::last_write_time(output));
|
|
}
|
|
|
|
expectChef(dirs, "", true, "a second cook must succeed");
|
|
for (std::size_t i = 0; i < outputs.size(); ++i) {
|
|
check(fs::last_write_time(outputs[i]) == times[i], "an unchanged source must not be cooked again");
|
|
}
|
|
}
|
|
|
|
void testDependencyChangesRecook()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_dependencies");
|
|
writeShaders(dirs);
|
|
writeModel(dirs);
|
|
expectChef(dirs, "", true, "the first cook must succeed");
|
|
|
|
const fs::path spv = dirs.output / "shaders" / "plain.frag.spv";
|
|
const auto staleSpv = makeStale(spv, dirs.input / "shaders" / "include" / "common.glsl");
|
|
const fs::path model = dirs.output / "models" / "tri.obj.dmodel";
|
|
const auto staleModel = makeStale(model, dirs.input / "models" / "tri.mtl");
|
|
// The entry files themselves stay older than the outputs, only the dependencies are newer
|
|
fs::last_write_time(dirs.input / "shaders" / "plain.frag", staleSpv - std::chrono::hours{1});
|
|
fs::last_write_time(dirs.input / "models" / "tri.obj", staleModel - std::chrono::hours{1});
|
|
|
|
expectChef(dirs, "", true, "recooking must succeed");
|
|
check(fs::last_write_time(spv) != staleSpv, "a changed include must recompile the shader");
|
|
check(fs::last_write_time(model) != staleModel, "a changed material library must recook the model");
|
|
}
|
|
|
|
void testReplacedSourceIsCopiedAgain()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_replaced");
|
|
const fs::path source = dirs.input / "notes.txt";
|
|
writeText(source, "new");
|
|
expectChef(dirs, "", true, "the first cook must succeed");
|
|
|
|
// Restoring an older file must still replace the copy, even though it isn't newer
|
|
writeText(source, "old!");
|
|
fs::last_write_time(source, fs::last_write_time(dirs.output / "notes.txt") - std::chrono::hours{24});
|
|
expectChef(dirs, "", true, "recooking must succeed");
|
|
check(readFile(dirs.output / "notes.txt") == "old!", "a replaced source must be copied again");
|
|
}
|
|
|
|
void testDeletedSourcesAreRemoved()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_deleted");
|
|
writeTga(dirs.input / "textures" / "old" / "gone.tga");
|
|
writeText(dirs.input / "keep.txt", "keep");
|
|
writeText(dirs.output / "hand_made.txt", "not ours");
|
|
expectChef(dirs, "", true, "the first cook must succeed");
|
|
check(fs::exists(dirs.output / "textures" / "old" / "gone.tga.dtex"), "the texture must be cooked first");
|
|
|
|
fs::remove_all(dirs.input / "textures");
|
|
expectChef(dirs, "", true, "cooking after a delete must succeed");
|
|
|
|
check(!fs::exists(dirs.output / "textures" / "old" / "gone.tga.dtex"), "cooked outputs of deleted sources are removed");
|
|
check(!fs::exists(dirs.output / "textures" / "old" / "gone.tga"), "copies of deleted sources are removed");
|
|
check(!fs::exists(dirs.output / "textures"), "folders emptied by the cleanup are removed");
|
|
check(fs::exists(dirs.output / "keep.txt"), "outputs of existing sources stay");
|
|
check(fs::exists(dirs.output / "hand_made.txt"), "files the cooker never wrote are left alone");
|
|
check(findEntry(readManifest(dirs), "textures/old/gone.tga") == nullptr, "deleted sources leave the manifest");
|
|
|
|
expectChef(dirs, "--validate", false, "validation must report files the cooker didn't write");
|
|
fs::remove(dirs.output / "hand_made.txt");
|
|
expectChef(dirs, "--validate", true, "validation passes once the stray file is gone");
|
|
}
|
|
|
|
void testFailedCookKeepsLastGoodOutput()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_failure");
|
|
writeShaders(dirs);
|
|
expectChef(dirs, "", true, "the first cook must succeed");
|
|
|
|
const fs::path spv = dirs.output / "shaders" / "plain.frag.spv";
|
|
const std::string goodSpv = readFile(spv);
|
|
|
|
writeText(dirs.input / "shaders" / "plain.frag", "#version 450\nvoid main() { this is not glsl }\n");
|
|
fs::last_write_time(dirs.input / "shaders" / "plain.frag", fs::last_write_time(spv) + std::chrono::hours{1});
|
|
writeText(dirs.input / "added.txt", "added");
|
|
|
|
expectChef(dirs, "", false, "a shader that doesn't compile must fail the cook");
|
|
check(readFile(spv) == goodSpv, "a failed compile must leave the previous SPIR-V untouched");
|
|
check(fs::exists(dirs.output / "added.txt"), "one failing asset must not stop the others");
|
|
check(!hasTempFiles(dirs.output), "a failed cook leaves no temporary files");
|
|
|
|
const auto manifest = readManifest(dirs);
|
|
const auto* shader = findEntry(manifest, "shaders/plain.frag");
|
|
check(shader && (*shader)["out"] == "shaders/plain.frag.spv", "the failed shader keeps its previous entry");
|
|
check(findEntry(manifest, "added.txt") != nullptr, "the manifest is still written after a failure");
|
|
|
|
expectChef(dirs, "", false, "the broken shader must be retried, and fail again");
|
|
writeShaders(dirs);
|
|
expectChef(dirs, "", true, "fixing the shader must make the cook succeed");
|
|
}
|
|
|
|
void testFallbacksAndStrictMode()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_fallback");
|
|
writeText(dirs.input / "broken.png", "this is not a png");
|
|
|
|
expectChef(dirs, "", true, "a fallback is only a warning by default");
|
|
check(fs::exists(dirs.output / "broken.png"), "the source is used when cooking fails");
|
|
check(!fs::exists(dirs.output / "broken.png.dtex"), "no cooked file is written when cooking fails");
|
|
const auto manifest = readManifest(dirs);
|
|
const auto* entry = findEntry(manifest, "broken.png");
|
|
check(entry && entry->contains("fallback"), "the manifest records the fallback");
|
|
|
|
expectChef(dirs, "--strict", false, "strict mode must fail on a remembered fallback");
|
|
expectChef(dirs, "--validate --strict", false, "strict validation must report the fallback");
|
|
|
|
writeText(dirs.input / "chef.json", R"({"allowFallback": ["broken.png"]})");
|
|
expectChef(dirs, "--strict", true, "strict mode must accept allowed fallbacks");
|
|
expectChef(dirs, "--validate --strict", true, "strict validation must accept allowed fallbacks");
|
|
check(!fs::exists(dirs.output / "chef.json"), "the cooker config isn't an asset");
|
|
}
|
|
|
|
void testValidateFindsMissingOutputs()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_validate");
|
|
writeShaders(dirs);
|
|
writeText(dirs.input / "notes.txt", "hello");
|
|
expectChef(dirs, "", true, "the first cook must succeed");
|
|
|
|
fs::remove(dirs.output / "shaders" / "plain.frag.spv");
|
|
expectChef(dirs, "--validate", false, "validation must report missing outputs");
|
|
|
|
expectChef(dirs, "", true, "recooking must succeed");
|
|
writeText(dirs.input / "new.txt", "new");
|
|
expectChef(dirs, "--validate", false, "validation must report sources that weren't cooked");
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
void testPackBundlesCookedOutputs()
|
|
{
|
|
const CookDirs dirs = makeDirs("destrum_cooker_pack");
|
|
writeShaders(dirs);
|
|
writeText(dirs.input / "notes.txt", "hello");
|
|
expectChef(dirs, "", true, "the first cook must succeed");
|
|
writeText(dirs.output / "stray.txt", "not cooked");
|
|
|
|
const fs::path pack = dirs.root / "assets.dpak";
|
|
const std::string packArgs = "--pack \"" + pack.string() + "\" --mount \"game=" + dirs.output.string() + "\"";
|
|
if (runChefArgs(dirs, packArgs) != 0) {
|
|
std::cerr << readFile(dirs.root / "chef.log") << '\n';
|
|
check(false, "packing a cooked folder must succeed");
|
|
return;
|
|
}
|
|
|
|
const PackFile::Reader reader{pack};
|
|
check(reader.Find("game/manifest.json") && reader.Find("game/shaders/plain.frag.spv") &&
|
|
reader.Find("game/notes.txt"),
|
|
"packs must hold the manifest and every cooked output");
|
|
check(!reader.Find("game/stray.txt") && !reader.Find("game/shaders/include/common.glsl"),
|
|
"packs must only hold what the manifest lists as outputs");
|
|
const auto notes = reader.Read(*reader.Find("game/notes.txt"));
|
|
check(std::string(notes.begin(), notes.end()) == "hello", "packed files must keep their contents");
|
|
|
|
check(runChefArgs(dirs, "--list \"" + pack.string() + "\" --top 0") == 0 &&
|
|
readFile(dirs.root / "chef.log").find("game/notes.txt") != std::string::npos,
|
|
"listing a pack must show its files");
|
|
check(runChefArgs(dirs, "--list \"" + dirs.output.string() + "\"") == 0 &&
|
|
readFile(dirs.root / "chef.log").find("Not in the manifest, won't be packed: 1 files") != std::string::npos,
|
|
"listing a cooked folder must point out files that won't be packed");
|
|
|
|
fs::remove(dirs.output / "notes.txt");
|
|
check(runChefArgs(dirs, packArgs) != 0, "packing must fail when a listed output is missing");
|
|
check(!fs::exists(pack.string() + ".tmp"), "a failed pack must not leave a temp file");
|
|
}
|
|
}
|
|
|
|
void RunCookerTests()
|
|
{
|
|
testCookRecordsEveryOutput();
|
|
testUnchangedSourcesAreSkipped();
|
|
testDependencyChangesRecook();
|
|
testReplacedSourceIsCopiedAgain();
|
|
testDeletedSourcesAreRemoved();
|
|
testFailedCookKeepsLastGoodOutput();
|
|
testFallbacksAndStrictMode();
|
|
testValidateFindsMissingOutputs();
|
|
testPackBundlesCookedOutputs();
|
|
}
|