rippled/src/test/core/JobQueue_test.cpp

#include <test/jtx/Env.h>

#include <xrpl/beast/unit_test.h>
#include <xrpl/core/JobQueue.h>

namespace xrpl {
namespace test {

//------------------------------------------------------------------------------

class JobQueue_test : public beast::unit_test::suite
{
    void
    testAddJob()
    {
        jtx::Env env{*this};

        JobQueue& jQueue = env.app().getJobQueue();
        {
            // addJob() should run the Job (and return true).
            std::atomic<bool> jobRan{false};
            BEAST_EXPECT(
                jQueue.addJob(jtCLIENT, "JobAddTest1", [&jobRan]() { jobRan = true; }) == true);

            // Wait for the Job to run.
            while (jobRan == false)
                ;
        }
        {
            // If the JobQueue is stopped, we should no
            // longer be able to add Jobs (and calling addJob() should
            // return false).
            using namespace std::chrono_literals;
            jQueue.stop();

            // The Job should never run, so having the Job access this
            // unprotected variable on the stack should be completely safe.
            // Not recommended for the faint of heart...
            bool unprotected;
            BEAST_EXPECT(jQueue.addJob(jtCLIENT, "JobAddTest2", [&unprotected]() {
                unprotected = false;
            }) == false);
        }
    }

    // NOTE: All coroutine lambdas passed to postCoroTask use explicit
    // pointer-by-value captures instead of [&] to work around a GCC 14
    // bug where reference captures in coroutine lambdas are corrupted
    // in the coroutine frame.

    void
    testPostCoroTask()
    {
        jtx::Env env{*this};

        JobQueue& jQueue = env.app().getJobQueue();
        {
            // Test repeated post()s until the coroutine completes.
            std::atomic<int> yieldCount{0};
            auto const runner = jQueue.postCoroTask(
                jtCLIENT, "PostCoroTest1", [ycp = &yieldCount](auto runner) -> CoroTask<void> {
                    while (++(*ycp) < 4)
                        co_await runner->suspend();
                    co_return;
                });
            BEAST_EXPECT(runner != nullptr);

            // Wait for the Job to run and yield.
            while (yieldCount == 0)
                ;

            // Now re-post until the CoroTaskRunner says it is done.
            int old = yieldCount;
            while (runner->runnable())
            {
                BEAST_EXPECT(runner->post());
                while (old == yieldCount)
                {
                }
                runner->join();
                BEAST_EXPECT(++old == yieldCount);
            }
            BEAST_EXPECT(yieldCount == 4);
        }
        {
            // Test repeated resume()s until the coroutine completes.
            int yieldCount{0};
            auto const runner = jQueue.postCoroTask(
                jtCLIENT, "PostCoroTest2", [ycp = &yieldCount](auto runner) -> CoroTask<void> {
                    while (++(*ycp) < 4)
                        co_await runner->suspend();
                    co_return;
                });
            if (!runner)
            {
                // There's no good reason we should not get a runner, but we
                // can't continue without one.
                BEAST_EXPECT(false);
                return;
            }

            // Wait for the Job to run and yield.
            runner->join();

            // Now resume until the CoroTaskRunner says it is done.
            int old = yieldCount;
            while (runner->runnable())
            {
                runner->resume();  // Resume runs synchronously on this thread.
                BEAST_EXPECT(++old == yieldCount);
            }
            BEAST_EXPECT(yieldCount == 4);
        }
        {
            // If the JobQueue is stopped, we should no
            // longer be able to post a coroutine (and calling postCoroTask()
            // should return nullptr).
            using namespace std::chrono_literals;
            jQueue.stop();

            // The coroutine should never run, so having it access this
            // unprotected variable on the stack should be completely safe.
            // Not recommended for the faint of heart...
            bool unprotected;
            auto const runner = jQueue.postCoroTask(
                jtCLIENT, "PostCoroTest3", [up = &unprotected](auto) -> CoroTask<void> {
                    *up = false;
                    co_return;
                });
            BEAST_EXPECT(runner == nullptr);
        }
    }

public:
    void
    run() override
    {
        testAddJob();
        testPostCoroTask();
    }
};

BEAST_DEFINE_TESTSUITE(JobQueue, core, xrpl);

}  // namespace test
}  // namespace xrpl