Revision control

+ // Copyright (C) 2026 The Qt Company Ltd.
+ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+ //
+ // codegen_selftest — exercises FuzzCppGenerator (the real generator, not a
+ // reimplementation) with hand-built MethodSignature lists, and asserts on
+ // the generated source text. No Qt dependency, no scanner/parsing needed —
+ // MethodSignature is constructed directly in-memory — so this runs
+ // identically and quickly on macOS, Windows, and Linux.
+ //
+ // Specifically guards against the two ways this generator has been shown to
+ // break in review: the switch-case / kDirectCallNames[] index alignment
+ // (buildDirectFuzzFunction) and unresolved @@..@@ template placeholders
+ // left in the final output (a forgotten replace() call).
+
+ #include "codegen.h"
+
+ #include <fstream>
+ #include <iostream>
+ #include <sstream>
+ #include <string>
+
+ using namespace QtFuzz;
+
+ namespace {
+
+ int g_failures = 0;
+
+ void check(bool cond, const std::string &what)
+ {
+ if (!cond) {
+ std::cerr << "FAIL: " << what << "\n";
+ ++g_failures;
+ } else {
+ std::cout << "ok: " << what << "\n";
+ }
+ }
+
+ std::string readFile(const std::string &path)
+ {
+ std::ifstream f(path);
+ std::ostringstream ss;
+ ss << f.rdbuf();
+ return ss.str();
+ }
+
+ MethodParam makeParam(std::string type)
+ {
+ MethodParam p;
+ p.type = std::move(type);
+ return p;
+ }
+
+ } // namespace
+
+ int main()
+ {
+ // ── Scenario 1: mixed trivial/non-trivial methods (hasQObject = false) ──
+ {
+ MethodSignature crashy;
+ crashy.name = "crashyMethod";
+ crashy.params.push_back(makeParam("int"));
+
+ MethodSignature safe;
+ safe.name = "safeMethod"; // zero params -> allBraces is false (see
+ // buildDirectFuzzFunction: !params.empty()),
+ // so this is also a real, emitted case.
+
+ std::vector<MethodSignature> methods = { crashy, safe };
+
+ const std::string outPath = "codegen_selftest_mixed.cpp";
+ FuzzCppGenerator gen("FakeClass", outPath, AppType::Core, methods,
+ /*hasQObject=*/false, "\"fakeclass.h\"");
+ check(gen.generate(), "mixed: generate() succeeds");
+
+ const std::string src = readFile(outPath);
+ check(!src.empty(), "mixed: output file is non-empty");
+ check(src.find("@@") == std::string::npos,
+ "mixed: no unresolved @@..@@ placeholder tokens remain");
+ check(src.find("static const char *const kDirectCallNames[] = {") != std::string::npos,
+ "mixed: kDirectCallNames[] array is emitted");
+ check(src.find("\"FakeClass::crashyMethod(int)\",") != std::string::npos,
+ "mixed: kDirectCallNames contains crashyMethod's signature");
+ check(src.find("\"FakeClass::safeMethod()\",") != std::string::npos,
+ "mixed: kDirectCallNames contains safeMethod's signature");
+ check(src.find("case 0:\n QtFuzzRuntime::setCurrentCall(kDirectCallNames[0]);\n"
+ " (void)obj.crashyMethod(") != std::string::npos,
+ "mixed: case 0 sets current call before invoking crashyMethod");
+ check(src.find("case 1:\n QtFuzzRuntime::setCurrentCall(kDirectCallNames[1]);\n"
+ " (void)obj.safeMethod();") != std::string::npos,
+ "mixed: case 1 sets current call before invoking safeMethod");
+ check(src.find("QtFuzzRuntime::installCrashHandler(\"FakeClass\");") != std::string::npos,
+ "mixed: installCrashHandler() is called with the class name");
+ check(src.find("QtFuzzRuntime::setIteration(iterations);") != std::string::npos,
+ "mixed: setIteration() is called in the fuzz loop");
+ }
+
+ // ── Scenario 2: every method trivially skipped -> no dispatch array ──────
+ {
+ MethodSignature trivial;
+ trivial.name = "trivialMethod";
+ // An unrecognized lowercase-leading type name falls through
+ // fuzzExprForType's final fallback to the bare "fd.nextInt()"
+ // sentinel — one of the four expressions buildDirectFuzzFunction's
+ // allBraces check treats as trivial enough to skip entirely.
+ trivial.params.push_back(makeParam("weirdlowercasetype"));
+
+ std::vector<MethodSignature> methods = { trivial };
+
+ const std::string outPath = "codegen_selftest_alltrivial.cpp";
+ FuzzCppGenerator gen("FakeClass2", outPath, AppType::Core, methods,
+ /*hasQObject=*/false, "\"fakeclass.h\"");
+ check(gen.generate(), "all-trivial: generate() succeeds");
+
+ const std::string src = readFile(outPath);
+ check(src.find("@@") == std::string::npos,
+ "all-trivial: no unresolved @@..@@ placeholder tokens remain");
+ check(src.find("kDirectCallNames") == std::string::npos,
+ "all-trivial: kDirectCallNames[] is NOT emitted (would be unused)");
+ }
+
+ // ── Scenario 3: Q_OBJECT path wires up the meta-invoke call site too ─────
+ {
+ std::vector<MethodSignature> methods; // empty: only test the QObject scaffolding
+ const std::string outPath = "codegen_selftest_qobject.cpp";
+ FuzzCppGenerator gen("FakeQObjectClass", outPath, AppType::Core, methods,
+ /*hasQObject=*/true, "\"fakeclass.h\"");
+ check(gen.generate(), "qobject: generate() succeeds");
+
+ const std::string src = readFile(outPath);
+ check(src.find("@@") == std::string::npos,
+ "qobject: no unresolved @@..@@ placeholder tokens remain");
+ check(src.find("QtFuzzRuntime::setCurrentCall(metaCallBuf);") != std::string::npos,
+ "qobject: invokeWithFuzzData records the meta-call before invoking");
+ check(src.find("QtFuzzRuntime::installCrashHandler(\"FakeQObjectClass\");") != std::string::npos,
+ "qobject: installCrashHandler() is called with the class name");
+ check(src.find("namespace QtFuzzRuntime {") != std::string::npos,
+ "qobject: crashdiag.h content is spliced into the output");
+ }
+
+ if (g_failures > 0) {
+ std::cerr << g_failures << " check(s) failed.\n";
+ return 1;
+ }
+ std::cout << "All checks passed.\n";
+ return 0;
+ }