#include "CanvasFonts.hpp" #include "stb_truetype.h" #include "UnitTest++/UnitTest++.h" #include #include #include #include #include #include #include #include #include #include namespace { const std::filesystem::path kSourceRoot = MODULES_SOURCE_DIR; const std::filesystem::path kResourceRoot = kSourceRoot / "GraphicApplication" / "rsc"; const std::vector kUiSourceDirectories = { "Widgets/private", "Widgets/public", "Taskboard/private", "Taskboard/public" }; class LoadedFont { public: explicit LoadedFont(const tp::FontFile& file) { std::ifstream stream(kResourceRoot / file.path, std::ios::binary); mBytes.assign(std::istreambuf_iterator(stream), {}); const auto* data = reinterpret_cast(mBytes.data()); mValid = !mBytes.empty() && stbtt_InitFont(&mInfo, data, stbtt_GetFontOffsetForIndex(data, 0)); } [[nodiscard]] bool isValid() const { return mValid; } [[nodiscard]] bool hasGlyph(char32_t codepoint) const { return mValid && stbtt_FindGlyphIndex(&mInfo, int(codepoint)) != 0; } private: std::vector mBytes; stbtt_fontinfo mInfo{}; bool mValid = false; }; std::optional decodeUtf8(const std::string& text, size_t& position) { const auto byte = [&](size_t offset) { return static_cast(text[position + offset]); }; const unsigned char lead = byte(0); const size_t length = lead < 0x80 ? 1 : lead >= 0xF0 ? 4 : lead >= 0xE0 ? 3 : lead >= 0xC0 ? 2 : 0; if (length == 0 || position + length > text.size()) { position++; return std::nullopt; } char32_t codepoint = length == 1 ? lead : lead & (0xFF >> (length + 1)); for (size_t index = 1; index < length; index++) { codepoint = (codepoint << 6) | (byte(index) & 0x3F); } position += length; return codepoint; } void collectEscapes(const std::string& source, std::set& codepoints) { static const std::regex escape(R"(\\u([0-9A-Fa-f]{4})|\\U([0-9A-Fa-f]{8}))"); for (std::sregex_iterator match(source.begin(), source.end(), escape), end; match != end; ++match) { const std::string digits = (*match)[1].matched ? (*match)[1].str() : (*match)[2].str(); codepoints.insert(char32_t(std::stoul(digits, nullptr, 16))); } } void collectLiterals(const std::string& source, std::set& codepoints) { for (size_t position = 0; position < source.size();) { const std::optional codepoint = decodeUtf8(source, position); if (codepoint && *codepoint >= 0x80) { codepoints.insert(*codepoint); } } } std::set codepointsUsedByUi() { std::set codepoints; for (const std::string& directory : kUiSourceDirectories) { if (!std::filesystem::is_directory(kSourceRoot / directory)) { continue; } for (const auto& entry : std::filesystem::recursive_directory_iterator(kSourceRoot / directory)) { if (!entry.is_regular_file()) { continue; } std::ifstream stream(entry.path(), std::ios::binary); const std::string source{ std::istreambuf_iterator(stream), {} }; collectEscapes(source, codepoints); collectLiterals(source, codepoints); } } return codepoints; } std::string hex(char32_t codepoint) { char buffer[16]; std::snprintf(buffer, sizeof(buffer), "U+%04X", unsigned(codepoint)); return buffer; } struct FaceChain { const char* label; tp::FontFile face; std::vector fallbacks; }; std::vector faceChains() { return { { "regular", tp::kRegularFont, { tp::kRegularFallbacks.begin(), tp::kRegularFallbacks.end() } }, { "bold", tp::kBoldFont, { tp::kBoldFallbacks.begin(), tp::kBoldFallbacks.end() } }, { "monospace", tp::kMonospaceFont, { tp::kMonospaceFallbacks.begin(), tp::kMonospaceFallbacks.end() } }, }; } const char* const kRussianAlphabetAndPunctuation = "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзийклмнопрстуфхцчшщъыьэюя№«»—–…"; std::set codepointsOf(const char* text) { std::set codepoints; const std::string source{ text }; for (size_t position = 0; position < source.size();) { const std::optional codepoint = decodeUtf8(source, position); if (codepoint) { codepoints.insert(*codepoint); } } return codepoints; } void checkChainCovers(const FaceChain& chain, const std::set& codepoints) { const LoadedFont primary(chain.face); std::vector fallbacks; for (const tp::FontFile& file : chain.fallbacks) { fallbacks.emplace_back(file); } for (const char32_t codepoint : codepoints) { bool covered = primary.hasGlyph(codepoint); for (const LoadedFont& fallback : fallbacks) { covered = covered || fallback.hasGlyph(codepoint); } CHECK_EQUAL( std::string(chain.label) + " " + hex(codepoint) + " drawn", std::string(chain.label) + " " + hex(codepoint) + (covered ? " drawn" : " has no glyph") ); } } template bool chainContains(const Chain& chain, const tp::FontFile& font) { for (const tp::FontFile& file : chain) { if (std::strcmp(file.path, font.path) == 0) { return true; } } return false; } } SUITE(FontCoverage) { TEST(EveryBundledFontLoads) { for (const tp::FontFile& file : tp::kTextFonts) { CHECK(LoadedFont(file).isValid()); } for (const tp::FontFile& file : tp::kFallbackFonts) { CHECK(LoadedFont(file).isValid()); } } TEST(EveryCharacterTheUiDrawsHasAGlyphInEveryTextFace) { const std::set used = codepointsUsedByUi(); for (const FaceChain& chain : faceChains()) { checkChainCovers(chain, used); } } TEST(RussianTextHasAGlyphInEveryTextFace) { const std::set russian = codepointsOf(kRussianAlphabetAndPunctuation); CHECK_EQUAL(size_t(72), russian.size()); for (const FaceChain& chain : faceChains()) { checkChainCovers(chain, russian); } } TEST(EachFaceFallsBackToTheCyrillicCutOfItsOwnWeight) { CHECK(chainContains(tp::kRegularFallbacks, tp::kCyrillicRegularFont)); CHECK(chainContains(tp::kMonospaceFallbacks, tp::kCyrillicRegularFont)); CHECK(chainContains(tp::kBoldFallbacks, tp::kCyrillicBoldFont)); CHECK(!chainContains(tp::kBoldFallbacks, tp::kCyrillicRegularFont)); CHECK(!chainContains(tp::kRegularFallbacks, tp::kCyrillicBoldFont)); } }