legacyAsyncErrorProbe()

fl::json autoresearch::legacyAsyncErrorProbe ( const fl::json & args )

inline

Definition at line 183 of file AutoResearchLegacyAsyncErrors.h.

                                                        {
    fl::json result = fl::json::object();
#if AUTORESEARCH_LEGACY_OBSERVES_RMT4_FRAMES && FL_RMT4_ASYNC // ok platform specific - native and other-backend builds return an explicit unsupported result.
    using namespace legacy_async_errors;
    const fl::string mode = args["mode"].as_string().value_or("unavailable");
    result.set("mode", mode);
    const bool injected = mode == "task-allocation" ||
        mode == "mutex-allocation" || mode == "install";
    const bool recoveryMode = mode == "timeout" || mode == "invalid-batch";
    if (mode != "unavailable" && mode != "setup" && !recoveryMode && !injected) {
        result.set("success", false);
        result.set("error", "Unknown legacy asynchronous failure fixture mode");
        return result;
    }
    if (mode == "timeout" &&
        (FASTLED_RMT4_TRANSMISSION_TIMEOUT_MS != 1 || !FL_RMT4_DIAGNOSTICS)) { // ok platform specific - this fixture requires RMT4-only worker diagnostics or fault-test configuration, with no neutral equivalent.
        result.set("success", false);
        result.set("error", "timeout fixture requires FASTLED_RMT4_TRANSMISSION_TIMEOUT_MS=1 and FL_RMT4_DIAGNOSTICS=1");
        return result;
    }
    if (mode == "invalid-batch" && !FL_RMT4_DIAGNOSTICS) { // ok platform specific - this fixture requires RMT4-only worker diagnostics or fault-test configuration, with no neutral equivalent.
        result.set("success", false);
        result.set("error", "invalid-batch fixture requires FL_RMT4_DIAGNOSTICS=1");
        return result;
    }
    if (!FastLED.wait(1000)) {
        result.set("success", false);
        result.set("error", "Existing output did not drain before fixture");
        return result;
    }
    if (injected) {
#if defined(FL_RMT4_FAULT_TEST) && FL_RMT4_FAULT_TEST == 1 // ok platform specific - injected failures require dedicated wrapper-linked test firmware.
        return injectedFailureProbe(mode);
#else
        result.set("success", false);
        result.set("error", "Requires FL_RMT4_FAULT_TEST=1 and the documented SDK linker wrappers");
        return result;
#endif
    }
    auto &manager = fl::RmtMemoryManager4::instance(); // ok platform specific - reserve and audit real RMT4 hardware blocks for exhaustion recovery; no neutral allocator exposes them.
    const size_t baseline = manager.allocatedWords(); // ok platform specific - reserve and audit real RMT4 hardware blocks for exhaustion recovery; no neutral allocator exposes them.
    auto frame = makeFrame(mode == "timeout" ? 4000 : 1);
    if (!frame) {
        result.set("success", false);
        result.set("error", "Fixture frame allocation failed");
        return result;
    }
    Observation observed;
    bool recovered = false;
    unsigned reserved = 0;
    fl::u32 reservationMask = 0;
    if (mode == "unavailable") {
        FreeBlockReservations reservations(manager);
        reserved = reservations.count();
        reservationMask = reservations.mask();
        fl::Rmt4AsyncDriver driver(fl::make_shared<fl::Rmt4PeripheralESP>()); // ok platform specific - construct an isolated RMT4 worker for backend-specific failure recovery, unavailable through the neutral factory.
        observed = submit(driver, frame);
    } else if (mode == "setup") {
        // A missing real peripheral exercises the existing setup-failure path;
        // no SDK return value or production behavior is replaced by a mock.
        fl::Rmt4AsyncDriver driver{fl::shared_ptr<fl::detail::IRMT4Peripheral>()}; // ok platform specific - construct an isolated RMT4 worker for backend-specific failure recovery, unavailable through the neutral factory.
        observed = submit(driver, frame);
    } else {
        fl::Rmt4AsyncDriver driver(fl::make_shared<fl::Rmt4PeripheralESP>()); // ok platform specific - construct an isolated RMT4 worker for backend-specific failure recovery, unavailable through the neutral factory.
        if (mode == "invalid-batch") {
            // The bridge rejects an unencodable strip this way. A subsequent
            // valid strip must not erase that failure from the same batch.
            driver.enqueue(fl::ChannelDataPtr());
        }
        observed = submit(driver, frame);
        recovered = recoverySucceeded(driver);
    }
    const size_t after = manager.allocatedWords(); // ok platform specific - reserve and audit real RMT4 hardware blocks for exhaustion recovery; no neutral allocator exposes them.
    bool reservationsRestored = true;
    for (unsigned block = 0; block < 32; ++block) {
        if (reservationMask & (fl::u32(1) << block)) {
            const bool available = manager.tryReserveBlocks(static_cast<int>(block), 1); // ok platform specific - reserve and audit real RMT4 hardware blocks for exhaustion recovery; no neutral allocator exposes them.
            reservationsRestored &= available;
            if (available) { manager.releaseBlocks(static_cast<int>(block), 1); } // ok platform specific - reserve and audit real RMT4 hardware blocks for exhaustion recovery; no neutral allocator exposes them.
        }
    }
    appendObservation(result, observed);
    result.set("reservedFreeBlocks", static_cast<int>(reserved));
    result.set("allocatedWordsBefore", static_cast<int>(baseline));
    result.set("allocatedWordsAfter", static_cast<int>(after));
    result.set("ledgerRestored", baseline == after);
    result.set("fixtureReservationsRestored", reservationsRestored);
    result.set("recoveryAttempted", recoveryMode);
    result.set("recoveredOnSameDriver", recoveryMode && recovered);
    result.set("success", observed.leasedAtSubmission &&
        observed.releasedAutonomously && observed.errorReported &&
        !observed.completionSucceeded && baseline == after &&
        (mode != "timeout" ||
            (observed.translatedBytes > 0 && observed.translatedBytes < frame->getSize())) &&
        (mode != "invalid-batch" || observed.translatedBytes == 3) &&
        reservationsRestored && (!recoveryMode || recovered));
#else
    (void)args;
    result.set("success", false);
    result.set("error", "Requires asynchronous classic ESP32 RMT4 output");
#endif
    return result;
}

References args, FastLED, fl::adl_barrier::make_shared(), and fl::json::object().

Here is the call graph for this function: