slick-queue-py/tests/cpp_read_last_tester.cpp at main · SlickQuant/slick-queue-py · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/**
 * C++ test program for read_last() interoperability with Python.
 *
 * Usage modes:
 *   1. Read mode:  cpp_read_last_tester <queue_name> read <element_size>
 *      - Opens queue and calls read_last()
 *      - Prints the data and size
 *
 *   2. Write mode: cpp_read_last_tester <queue_name> write <size> <count> <element_size>
 *      - Creates/opens queue
 *      - Publishes <count> items
 *      - Calls read_last() to verify
 */

#include <slick/queue.hpp>
#include <iostream>
#include <cstring>
#include <cstdint>

struct Element {
    uint32_t value;
    char padding[28];  // Pad to 32 bytes
};

void print_usage() {
    std::cout << "Usage:\n"
              << "  Read mode:  cpp_read_last_tester <queue_name> read <element_size>\n"
              << "  Write mode: cpp_read_last_tester <queue_name> write <size> <count> <element_size>\n";
}

int read_mode(const char* queue_name, uint32_t element_size) {
    try {
        // Open existing queue
        slick::queue<Element> queue(queue_name);

        std::cout << "C++ opened queue: " << queue_name << std::endl;
        std::cout << "  Queue size: " << queue.size() << std::endl;

        // Call read_last()
        auto [data, size] = queue.read_last();

        if (data == nullptr) {
            std::cout << "read_last() returned: nullptr (queue empty or no data)" << std::endl;
            std::cout << "  size: " << size << std::endl;
            return 0;
        }

        std::cout << "read_last() returned:" << std::endl;
        std::cout << "  data->value: " << data->value << std::endl;
        std::cout << "  size: " << size << std::endl;

        // Print first few bytes as hex
        std::cout << "  first 16 bytes: ";
        const uint8_t* bytes = reinterpret_cast<const uint8_t*>(data);
        for (auto i = 0u; i < 16 && i < element_size; i++) {
            printf("%02X ", bytes[i]);
        }
        std::cout << std::endl;

        return 0;

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
}

int write_mode(const char* queue_name, uint32_t queue_size, uint32_t count, uint32_t element_size) {
    try {
        // Create/open queue
        slick::queue<Element> queue(queue_size, queue_name);

        std::cout << "C++ created/opened queue: " << queue_name << std::endl;
        std::cout << "  Queue size: " << queue.size() << std::endl;
        std::cout << "  Publishing " << count << " items..." << std::endl;

        // Publish items
        for (uint32_t i = 0; i < count; i++) {
            uint64_t idx = queue.reserve();
            Element* elem = queue[idx];
            elem->value = 2000 + i;  // Use offset to distinguish from Python
            queue.publish(idx);

            if (i < 5 || i >= count - 5) {
                std::cout << "    Item " << i << ": value=" << elem->value << std::endl;
            } else if (i == 5) {
                std::cout << "    ..." << std::endl;
            }
        }

        std::cout << "Publishing complete." << std::endl;

        // Call read_last() to verify
        auto [data, size] = queue.read_last();

        if (data == nullptr) {
            std::cerr << "Error: read_last() returned nullptr after publishing!" << std::endl;
            return 1;
        }

        std::cout << "\nC++ read_last() verification:" << std::endl;
        std::cout << "  data->value: " << data->value << std::endl;
        std::cout << "  size: " << size << std::endl;

        uint32_t expected = 2000 + count - 1;
        if (data->value != expected) {
            std::cerr << "Error: Expected value " << expected << ", got " << data->value << std::endl;
            return 1;
        }

        std::cout << "  [OK] Value matches expected" << std::endl;

        return 0;

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
}

int main(int argc, char* argv[]) {
    if (argc < 3) {
        print_usage();
        return 1;
    }

    const char* queue_name = argv[1];
    const char* mode = argv[2];

    if (strcmp(mode, "read") == 0) {
        if (argc != 4) {
            std::cerr << "Error: Read mode requires: <queue_name> read <element_size>" << std::endl;
            return 1;
        }
        uint32_t element_size = std::atoi(argv[3]);
        return read_mode(queue_name, element_size);

    } else if (strcmp(mode, "write") == 0) {
        if (argc != 6) {
            std::cerr << "Error: Write mode requires: <queue_name> write <size> <count> <element_size>" << std::endl;
            return 1;
        }
        uint32_t queue_size = std::atoi(argv[3]);
        uint32_t count = std::atoi(argv[4]);
        uint32_t element_size = std::atoi(argv[5]);
        return write_mode(queue_name, queue_size, count, element_size);

    } else {
        std::cerr << "Error: Unknown mode '" << mode << "'" << std::endl;
        print_usage();
        return 1;
    }
}