Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.
C++ 3d3d-sculptingcppdear-imguidigital-sculptingfbxgame-developmentgaussian-splattinggltfimage-to-3dmcpopenglopenusdsculptingtext-to-3dunreal-engine
// SculptForge - open source digital sculpting
// SPDX-License-Identifier: GPL-3.0-or-later
//
// Supporting SculptForge: the supporters list (docs/supporters.txt) and the Founding Members (website/founding.json)
// parsed and sanitised for Help > About, and when the membership cards may show.
#include "TestHarness.h"
#include "app/Support.h"
#include <cstdio>
#include <fstream>
#include <iterator>
#include <string>
using namespace sf;
TEST(supporters_parse_skips_comments_and_blanks) {
CHECK(parseSupporters("").empty());
CHECK(parseSupporters("# one name per line\n\n \n#Not a name\n").empty());
const auto names = parseSupporters("# header\nAda Lovelace\r\n Grace Hopper \n\nLinus\n");
CHECK(names.size() == 3);
CHECK(names[0] == "Ada Lovelace" && names[1] == "Grace Hopper" && names[2] == "Linus");
CHECK(std::string(kSupportUrl) == "https://sculptforge.app/support.html");
CHECK(std::string(kDiscordUrl) == "https://discord.gg/gWrYkEmQhH");
}
TEST(supporters_names_are_sanitised) {
// Control characters, escapes and invisible formatting go; the rest stays as plain text.
CHECK(sanitizeSupporterName("Bob\x1b[31m\x07") == "Bob[31m");
CHECK(sanitizeSupporterName("A\tB\x7f" "C") == "ABC");
CHECK(sanitizeSupporterName("\xe2\x80\xae" "evil\xe2\x80\xac") == "evil"); // bidi override (U+202E, U+202C)
CHECK(sanitizeSupporterName("zero\xe2\x80\x8bwidth\xef\xbb\xbf") == "zerowidth"); // U+200B, BOM
CHECK(sanitizeSupporterName("\xc2\x85" "next") == "next"); // C1 control (U+0085)
CHECK(sanitizeSupporterName("Ren\xc3\xa9 \xe5\xb1\xb1\xe7\x94\xb0") == "Ren\xc3\xa9 \xe5\xb1\xb1\xe7\x94\xb0"); // UTF-8 kept
CHECK(sanitizeSupporterName("bad\xff\xc0\xafutf8\xed\xa0\x80") == "badutf8"); // invalid, overlong, surrogate
CHECK(sanitizeSupporterName("%s%n{{markup}}") == "%s%n{{markup}}"); // shown as text, not interpreted
// 40 characters at most, counted in characters, never cutting one in half.
CHECK(sanitizeSupporterName(std::string(100, 'x')).size() == kSupporterNameMax);
std::string accents;
for (int i = 0; i < 50; ++i) accents += "\xc3\xa9";
CHECK(sanitizeSupporterName(accents).size() == kSupporterNameMax * 2);
CHECK(sanitizeSupporterName(" \x01 \x02 ").empty());
}
TEST(supporters_count_is_capped) {
std::string text;
for (int i = 0; i < 2500; ++i) text += "Name " + std::to_string(i) + "\n";
const auto names = parseSupporters(text);
CHECK(names.size() == kSupportersMax);
CHECK(names.back() == "Name 1999");
}
TEST(member_card_sculpting_moment) {
// Stroke time grows by frames spent in strokes, a stalled frame counting at most a quarter second.
double t = 0.0;
t = addSculptTime(t, 0.016);
CHECK(t > 0.015 && t < 0.017);
CHECK(addSculptTime(t, 3600.0) - t <= kSculptTimeMaxStep + 1e-9);
CHECK(addSculptTime(t, -5.0) == t);
CHECK(addSculptTime(-1.0, 0.1) <= 0.1 + 1e-9); // a damaged value starts again
// About 20 minutes of active sculpting in this session (the maintainer, 11-05: an hour was too long), once per session.
CHECK(kMemberCardSculptSeconds == 20.0 * 60.0);
CHECK(!sculptMomentDue(kMemberCardSculptSeconds - 1.0, false));
CHECK(sculptMomentDue(kMemberCardSculptSeconds, false));
CHECK(!sculptMomentDue(kMemberCardSculptSeconds * 3.0, true));
}
TEST(member_card_weekly_until_member) {
const int64_t day = 24 * 3600, now = 1'800'000'000;
SupportCardPrefs p;
CHECK(memberMomentAllowed(p, false, now, false)); // never shown: yes
p.shownAt = now;
CHECK(!memberMomentAllowed(p, false, now + 6 * day, false)); // at most once a week
CHECK(memberMomentAllowed(p, false, now + 7 * day, false));
CHECK(memberMomentAllowed(p, false, now + 70 * day, false)); // and weekly again, for as long as it takes
CHECK(memberMomentAllowed(p, false, now - 30 * day, false)); // a clock set back can't hide it for good
CHECK(!memberMomentAllowed(p, false, now - day, false));
// Never in tests, renders or CI; never for a member signed in for member builds.
CHECK(!memberMomentAllowed(p, false, now + 30 * day, true));
CHECK(!memberMomentAllowed(p, true, now + 30 * day, false));
// Never mid-stroke, during a background job or over another card: it waits.
CHECK(memberCardMayOpen(false, false, false));
CHECK(!memberCardMayOpen(true, false, false));
CHECK(!memberCardMayOpen(false, true, false));
CHECK(!memberCardMayOpen(false, false, true));
}
TEST(member_card_choices) {
const int64_t day = 24 * 3600, now = 1'800'000'000;
// Not now: a week.
SupportCardPrefs p;
p.shownAt = now;
applyMemberCardChoice(p, MemberCardChoice::NotNow, now);
CHECK(!memberMomentAllowed(p, false, now + 6 * day, false));
CHECK(memberMomentAllowed(p, false, now + 7 * day, false));
CHECK(!p.supporter);
// Become a member opens the checkout; the card comes back in a week unless they sign in.
SupportCardPrefs b;
applyMemberCardChoice(b, MemberCardChoice::Become, now);
CHECK(!memberMomentAllowed(b, false, now + 6 * day, false));
CHECK(memberMomentAllowed(b, false, now + 7 * day, false));
// I'm already a member, signed in (GitHub, access to the member repository): gone for good.
SupportCardPrefs ok;
applyMemberCardChoice(ok, MemberCardChoice::SignedIn, now);
CHECK(ok.supporter);
for (int64_t d : {7, 30, 365, 3650}) CHECK(!memberMomentAllowed(ok, false, now + d * day, false));
CHECK(supportCardDue(ok, true, false) == SupportCardReason::None);
// I'm already a member, no sign-in (cancelled, declined, no access): three months, then weekly again.
SupportCardPrefs no;
no.shownAt = now;
applyMemberCardChoice(no, MemberCardChoice::NoSignIn, now);
CHECK(!no.supporter);
CHECK(!memberMomentAllowed(no, false, now + 7 * day, false));
CHECK(!memberMomentAllowed(no, false, now + 89 * day, false));
CHECK(memberMomentAllowed(no, false, now + 90 * day, false));
no.shownAt = now + 90 * day;
CHECK(!memberMomentAllowed(no, false, now + 96 * day, false));
CHECK(memberMomentAllowed(no, false, now + 97 * day, false));
// A snooze further off than any choice makes (a damaged value, a clock set back) doesn't hide it.
SupportCardPrefs bad;
bad.hiddenUntil = now + 400 * day;
CHECK(memberMomentAllowed(bad, false, now, false));
}
TEST(founding_members_json) {
const FoundingMembers none = parseFoundingMembers("");
CHECK(none.limit == 100 && none.taken == 0 && none.open() && none.left() == 100 && none.names.empty());
const FoundingMembers f = parseFoundingMembers(R"({"limit": 100, "taken": 37, "names": ["Ada", "\u202eevil", 5, ""]})");
CHECK(f.taken == 37 && f.left() == 63 && f.open());
CHECK(f.names.size() == 2 && f.names[0] == "Ada" && f.names[1] == "evil"); // sanitised, non-strings and blanks skipped
const FoundingMembers full = parseFoundingMembers(R"({"limit": 100, "taken": 140})");
CHECK(full.taken == 100 && !full.open() && full.left() == 0); // the founding note switches off at 100
CHECK(parseFoundingMembers(R"({"limit": -3, "taken": -1})").limit == 100);
CHECK(parseFoundingMembers(R"({"limit": -3, "taken": -1})").taken == 0);
// The repository's file (compiled into the app, read by the website) parses as written.
std::ifstream in(std::string(SF_TEST_DATA_DIR) + "/../../website/founding.json", std::ios::binary);
CHECK(in.good());
const std::string text{std::istreambuf_iterator<char>(in), {}};
Json j;
std::string error;
CHECK(Json::parse(text, j, error) && j["limit"].isNumber() && j["taken"].isNumber() && j["names"].isArray());
}
TEST(support_card_links_match_the_website) {
// The card opens the same Stripe checkout pages as the membership page and the studio page (never links of its own).
auto read = [](const char* name) {
std::ifstream f(std::string(SF_TEST_DATA_DIR) + "/../../website/" + name, std::ios::binary);
CHECK(f.good());
return std::string{std::istreambuf_iterator<char>(f), {}};
};
const std::string page = read("support.html"), studios = read("studios.html");
for (const char* url : {kSupportUrlMember, kSupportUrlStudio}) {
CHECK(std::string(url).rfind("https://buy.stripe.com/", 0) == 0);
CHECK(page.find(std::string("href=\"") + url + "\"") != std::string::npos);
}
CHECK(studios.find(std::string("href=\"") + kSupportUrlStudio + "\"") != std::string::npos);
// The yearly Member checkout: the same on both, or empty on both (the yearly choice hidden until it exists).
const std::string yearly(kSupportUrlMemberYearly);
CHECK(yearly.empty() || yearly.rfind("https://buy.stripe.com/", 0) == 0);
CHECK(page.find("data-yearly=\"" + yearly + "\"") != std::string::npos);
CHECK(page.find(kFreeReleaseNote) != std::string::npos); // the same honest wording on both
CHECK(page.find(std::string("href=\"") + kDiscordUrl + "\"") != std::string::npos); // the same community invite
// Retired: the Insider tier, one-time payments and the monthly pack, and Studio's per-artist price (Tony 11-06: a flat
// $300 / month for any number of artists, Founding Studio a flat $150); the old wording that contradicts it is gone.
for (const std::string& p : {page, studios})
for (const char* old : {"Insider", "One-time", "one-time", "$20", "monthly pack", "pack every month", "whole company",
"no seat count", "5 custom items", "10 artists", "$25"}) {
if (p.find(old) != std::string::npos) std::printf(" retired wording on the site: \"%s\"\n", old);
CHECK(p.find(old) == std::string::npos);
}
for (const std::string& p : {page, studios})
for (const char* now : {"$300", "Founding Studio", "$150", "3 custom items", "no outside connections", "any number of artists"}) {
if (p.find(now) == std::string::npos) std::printf(" missing on the site: \"%s\"\n", now);
CHECK(p.find(now) != std::string::npos);
}
CHECK(studios.find("GPL-3.0") != std::string::npos && studios.find("no exclusive or secret features") != std::string::npos);
CHECK(std::string(kStudioPageUrl) == "https://sculptforge.app/studios.html#membership");
// Terms & refunds: the terms page exists, carries the refund wording and is linked from both pages.
CHECK(std::string(kTermsUrl) == "https://sculptforge.app/terms.html");
const std::string terms = read("terms.html");
CHECK(terms.find("id=\"refunds\"") != std::string::npos && terms.find("Memberships aren't refundable.") != std::string::npos);
CHECK(page.find("href=\"terms.html#refunds\"") != std::string::npos);
CHECK(studios.find("href=\"terms.html") != std::string::npos);
// Founding Members and Member Requests on the membership page; its counter reads founding.json.
CHECK(page.find("Founding Member") != std::string::npos);
CHECK(page.find("Member Requests") != std::string::npos);
CHECK(page.find("founding.json") != std::string::npos);
}
TEST(support_card_opens_only_its_fixed_links) {
for (const char* url : {kSupportUrlMember, kSupportUrlMemberYearly, kSupportUrlStudio, kStudioPageUrl, kTermsUrl})
CHECK(url[0] == '\0' || supportLinkAllowed(url));
for (const char* url : {"", "https://sculptforge.app/terms.html.evil.example", "https://sculptforge.app/terms.htm",
"file:///etc/passwd", "https://buy.stripe.com/", "javascript:alert(1)"})
CHECK(!supportLinkAllowed(url));
}
TEST(support_card_timing) {
// The full card: the first start only (Help > Support and the welcome open it by hand).
SupportCardPrefs p;
CHECK(supportCardDue(p, true, false) == SupportCardReason::FirstRun);
CHECK(supportCardDue(p, false, false) == SupportCardReason::None);
CHECK(supportCardDue(p, true, true) == SupportCardReason::None); // never in tests, renders or CI
SupportCardPrefs member = p;
member.supporter = true;
CHECK(supportCardDue(member, true, false) == SupportCardReason::None);
}
TEST(member_card_backoff) {
const int64_t day = 24 * 3600, now = 1'800'000'000;
SupportCardPrefs p;
// Weekly for the first two "Not now"s.
for (int i = 1; i <= 2; ++i) {
p.shownAt = now;
applyMemberCardChoice(p, MemberCardChoice::NotNow, now);
CHECK(p.notNow == i);
CHECK(!memberMomentAllowed(p, false, now + 6 * day, false));
CHECK(memberMomentAllowed(p, false, now + 7 * day, false));
}
// After the 3rd: monthly (the snooze and the gap between cards).
applyMemberCardChoice(p, MemberCardChoice::NotNow, now);
CHECK(p.notNow == 3);
CHECK(!memberMomentAllowed(p, false, now + 29 * day, false));
CHECK(memberMomentAllowed(p, false, now + 30 * day, false));
p.hiddenUntil = 0;
CHECK(!memberMomentAllowed(p, false, now + 8 * day, false)); // shown a week ago: not yet
// Become a member snoozes as long without counting as a "Not now".
SupportCardPrefs b = p;
applyMemberCardChoice(b, MemberCardChoice::Become, now);
CHECK(b.notNow == 3 && b.hiddenUntil == now + 30 * day);
// After the 6th: only the first start after an update (still at most monthly).
for (int i = 0; i < 3; ++i) applyMemberCardChoice(p, MemberCardChoice::NotNow, now);
CHECK(p.notNow == 6);
for (MemberMoment m : {MemberMoment::Sculpted, MemberMoment::SavedRender, MemberMoment::Challenge, MemberMoment::Starts,
MemberMoment::SculptHours, MemberMoment::Saves, MemberMoment::None})
CHECK(!memberMomentAllowed(p, false, now + 60 * day, false, m));
CHECK(!memberMomentAllowed(p, false, now + 29 * day, false, MemberMoment::Updated));
CHECK(memberMomentAllowed(p, false, now + 60 * day, false, MemberMoment::Updated));
// Members and tests: never, whatever the moment.
CHECK(!memberMomentAllowed(p, true, now + 60 * day, false, MemberMoment::Updated));
CHECK(!memberMomentAllowed(p, false, now + 60 * day, true, MemberMoment::Updated));
}
TEST(member_card_milestones) {
SupportCardPrefs p;
CHECK(milestoneDue(p) == MemberMoment::None);
p.starts = kMilestoneStarts - 1;
p.sculptSeconds = kMilestoneSculptSeconds - 1.0;
p.saves = kMilestoneSaves - 1;
CHECK(milestoneDue(p) == MemberMoment::None);
// The 10th start, 10 hours of sculpting, the 100th save; each once, in that order when several are due.
p.starts = 14;
p.sculptSeconds = 12.7 * 3600.0;
p.saves = 100;
CHECK(milestoneDue(p) == MemberMoment::Starts);
p.milestonesShown |= milestoneBit(MemberMoment::Starts);
CHECK(milestoneDue(p) == MemberMoment::SculptHours);
p.milestonesShown |= milestoneBit(MemberMoment::SculptHours);
CHECK(milestoneDue(p) == MemberMoment::Saves);
p.milestonesShown |= milestoneBit(MemberMoment::Saves);
CHECK(milestoneDue(p) == MemberMoment::None);
CHECK(milestoneBit(MemberMoment::Sculpted) == 0);
// The words state the true number as it shows (hours whole, rounded down).
auto words = [&](MemberMoment m) {
const CardLine l = milestoneLine(m, p);
return formatCardLine(l, l.format);
};
CHECK(words(MemberMoment::Starts) == "You've opened SculptForge 14 times. Members keep it free and growing.");
CHECK(words(MemberMoment::SculptHours) == "You've sculpted 12 hours in SculptForge. Members keep it free and growing.");
CHECK(words(MemberMoment::Saves) == "You've saved your work 100 times in SculptForge. Members keep it free and growing.");
CHECK(words(MemberMoment::Updated).empty());
// A milestone still counts against the weekly limit like any moment.
const int64_t day = 24 * 3600, now = 1'800'000'000;
SupportCardPrefs q;
q.shownAt = now;
CHECK(!memberMomentAllowed(q, false, now + 3 * day, false, MemberMoment::Starts));
CHECK(memberMomentAllowed(q, false, now + 7 * day, false, MemberMoment::Starts));
}
TEST(member_card_feed_lines) {
// No "support" block: no line (the card keeps its Founding Members words).
SupportFeed none;
CHECK(supportFeedLines(none).empty());
CHECK(supportFeedLine(none, 3).format == nullptr);
// The feed's block, parsed and checked (core/UpdateCheck.h).
UpdateInfo u;
std::string err;
CHECK(parseUpdateFeed(R"({"version": "9.0.0", "download": "https://sculptforge.app/#download",
"support": {"funded_this_month": ["Cloth brush", "Faster \u0007remesh", 7, "", "c", "d", "e", "f"],
"founding": {"taken": 2, "limit": 100}, "member_requests_this_release": 3}})",
u, err));
CHECK(u.support.present);
CHECK(u.support.funded.size() == 5 && u.support.funded[1] == "Faster remesh");
CHECK(u.support.foundingTaken == 2 && u.support.foundingLimit == 100 && u.support.memberRequests == 3);
const std::vector<CardLine> lines = supportFeedLines(u.support);
CHECK(lines.size() == 3);
auto words = [](const CardLine& l) { return formatCardLine(l, l.format); };
CHECK(words(lines[0]) == "Members funded this month: Cloth brush, Faster remesh, c, d, e.");
CHECK(words(lines[1]) ==
"Founding Members so far: 2 of 100. A badge, your name in the credits and your price locked for good.");
CHECK(words(lines[2]) == "3 changes in this release were members' requests.");
// They take turns, card by card.
CHECK(words(supportFeedLine(u.support, 0)) == words(lines[0]));
CHECK(words(supportFeedLine(u.support, 4)) == words(lines[1]));
// Odd values are left out, never guessed: a full founding list, taken over the limit, fractions, negatives.
UpdateInfo odd;
CHECK(parseUpdateFeed(R"({"version": "9.0.0", "download": "https://sculptforge.app/#download",
"support": {"founding": {"taken": 120, "limit": 100}, "member_requests_this_release": 2.5}})",
odd, err));
CHECK(odd.support.present && odd.support.foundingTaken == -1 && odd.support.memberRequests == -1);
CHECK(supportFeedLines(odd.support).empty());
SupportFeed full;
full.foundingTaken = full.foundingLimit = 100;
full.memberRequests = 1;
const std::vector<CardLine> one = supportFeedLines(full); // (no founding line once they're all taken)
CHECK(one.size() == 1 && words(one[0]) == "1 change in this release was a member's request.");
// No block at all: not present.
UpdateInfo plain;
CHECK(parseUpdateFeed(R"({"version": "9.0.0", "download": "https://sculptforge.app/#download"})", plain, err));
CHECK(!plain.support.present);
}