Jungfraujoch/tests/JFJochImageBufferReaderTest.cpp

// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#include <catch2/catch_all.hpp>
#include <cstring>
#include <future>
#include <thread>

#include "../reader/JFJochImageBufferReader.h"
#include "../common/ZeroCopyReturnValue.h"
#include "../frame_serialize/CBORStream2Serializer.h"

// The receiver's way of putting an image in the buffer: serialize the message into a slot, hand it out.
static void PutImage(ImageBuffer &buffer, const DiffractionExperiment &experiment, int64_t number,
                     const std::vector<int32_t> &pixels) {
    DataMessage msg{};
    msg.number = number;
    msg.image = CompressedImage(pixels, experiment.GetXPixelsNum(), experiment.GetYPixelsNum());
    auto loc = buffer.GetImageSlot();
    REQUIRE(loc != nullptr);
    CBORStream2Serializer serializer((uint8_t *) loc->GetImage(), experiment.GetImageBufferLocationSize());
    serializer.SerializeImage(msg);
    loc->SetImageNumber(number);
    loc->SetImageSize(serializer.GetBufferSize());
    loc->SetIndexed(false);
    loc->ReadyToSend();
    loc->release();
}

TEST_CASE("JFJochImageBufferReader", "[JFJochReader]") {
    DiffractionExperiment experiment(DetJF(1));
    experiment.ImagesPerTrigger(200);

    ImageBuffer buffer(16 * experiment.GetImageBufferLocationSize());
    buffer.StartMeasurement(experiment);

    StartMessage start{};
    experiment.FillMessage(start);
    REQUIRE(start.number_of_images == 200);

    JFJochImageBufferReader reader(buffer);
    reader.Open(start);
    REQUIRE(reader.GetNumberOfImages() == 200);
    REQUIRE(reader.GetDataset());

    const size_t npixel = experiment.GetXPixelsNum() * experiment.GetYPixelsNum();
    std::vector<int32_t> pixels(npixel, 7);
    pixels[123] = 4567;
    PutImage(buffer, experiment, 0, pixels);

    JFJochReaderRawImage raw;
    REQUIRE(reader.ReadRawImage(0, raw));
    REQUIRE(raw.image.GetWidth() == experiment.GetXPixelsNum());
    REQUIRE(raw.image.GetHeight() == experiment.GetYPixelsNum());
    REQUIRE(raw.image_buffer.size() == npixel * sizeof(int32_t));
    int32_t value;
    memcpy(&value, raw.image.GetCompressed() + 123 * sizeof(int32_t), sizeof(int32_t));
    REQUIRE(value == 4567);

    auto image = reader.LoadImage(0);
    REQUIRE(image);
    REQUIRE(image->ImageData().number == 0);

    REQUIRE_THROWS(reader.ReadRawImage(200, raw));

    // An image not there yet is waited for: the read returns once the receiver puts it in.
    auto pending = std::async(std::launch::async, [&] {
        JFJochReaderRawImage r;
        return reader.ReadRawImage(1, r);
    });
    REQUIRE(pending.wait_for(std::chrono::milliseconds(50)) == std::future_status::timeout);
    PutImage(buffer, experiment, 1, pixels);
    REQUIRE(pending.wait_for(std::chrono::seconds(5)) == std::future_status::ready);
    REQUIRE(pending.get());

    // Many readers waiting at once, as rugnux's workers do: each gets its image as it comes.
    std::vector<std::future<bool>> waiting;
    for (int64_t i = 2; i < 10; i++)
        waiting.push_back(std::async(std::launch::async, [&reader, i] {
            JFJochReaderRawImage r;
            return reader.ReadRawImage(i, r) && r.image.GetWidth() > 0;
        }));
    for (int64_t i = 2; i < 10; i++)
        PutImage(buffer, experiment, i, pixels);
    for (auto &w: waiting) {
        REQUIRE(w.wait_for(std::chrono::seconds(5)) == std::future_status::ready);
        REQUIRE(w.get());
    }

    // Images arrive in order, give or take a few: one still missing when an image MAX_IMAGE_LAG past
    // it is there is lost, while one nearer may still come.
    PutImage(buffer, experiment, 150, pixels);
    auto lost = std::async(std::launch::async, [&] {
        JFJochReaderRawImage r;
        return reader.ReadRawImage(150 - JFJochImageBufferReader::MAX_IMAGE_LAG, r);
    });
    REQUIRE(lost.wait_for(std::chrono::seconds(5)) == std::future_status::ready);
    REQUIRE(!lost.get());

    // After the end, an image that never came is not waited for.
    auto missing = std::async(std::launch::async, [&] {
        JFJochReaderRawImage r;
        return reader.ReadRawImage(150 - JFJochImageBufferReader::MAX_IMAGE_LAG + 1, r);
    });
    REQUIRE(missing.wait_for(std::chrono::milliseconds(300)) == std::future_status::timeout);
    reader.Ended();
    REQUIRE(missing.wait_for(std::chrono::seconds(5)) == std::future_status::ready);
    REQUIRE(!missing.get());

    REQUIRE(buffer.Finalize(std::chrono::microseconds(1)));
}