Add tests

CMakeLists.txt

@@ -18,7 +18,7 @@ add_library(miniraft
 
 add_executable(test_raft test/test_raft.cpp)
 
-target_include_directories(test_raft PRIVATE ${CMOCKA_INCLUDE_DIRS})
+target_include_directories(test_raft PRIVATE ${CMOCKA_INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/src)
 target_link_directories(test_raft PRIVATE ${CMOCKA_LIBRARY_DIRS})
 target_link_libraries(test_raft miniraft ${CMOCKA_LIBRARIES})
 

src/messages.h

@@ -1,7 +1,113 @@
 #pragma once
+#include <memory>
+#include <iostream>
 
-struct TLogEntry {
-    int Term = 1;
-    int Size = 0;
+#include <stdint.h>
+#include <typeinfo>
+
+enum class EMessageType : uint32_t {
+    NONE = 0,
+    LOG_ENTRY = 1,
+    REQUEST_VOTE_REQUEST = 2,
+};
+
+struct TMessage {
+    static constexpr EMessageType MessageType = EMessageType::NONE;
+    uint32_t Type;
+    uint32_t Len;
+    char Value[0];
+};
+
+struct TLogEntry: public TMessage {
+    static constexpr EMessageType MessageType = EMessageType::LOG_ENTRY;
+    uint64_t Term = 1;
     char Data[0];
 };
+
+struct RequestVoteRequest: public TMessage {
+    static constexpr EMessageType MessageType = EMessageType::REQUEST_VOTE_REQUEST;
+    uint64_t Term;
+    uint64_t LastLogIndex;
+    uint64_t LastLogTerm;
+    uint32_t Src;
+    uint32_t Dst;
+    uint32_t CandidateId;
+};
+
+template<typename T>
+requires std::derived_from<T, TMessage>
+struct TMessageHolder {
+    T* Mes;
+    std::shared_ptr<char[]> RawData;
+
+    template<typename U>
+    requires std::derived_from<U, T>
+    TMessageHolder(U* u, const std::shared_ptr<char[]>& rawData)
+        : Mes(u)
+        , RawData(rawData)
+    { }
+
+    template<typename U>
+    requires std::derived_from<U, T>
+    TMessageHolder(const TMessageHolder<U>& other)
+        : Mes(other.Mes)
+        , RawData(other.RawData)
+    { }
+
+    T* operator->() {
+        return Mes;
+    }
+
+    template<typename U>
+    requires std::derived_from<U, T>
+    TMessageHolder<U> Cast() {
+        return TMessageHolder<U>(static_cast<U*>(Mes), RawData);
+    }
+
+    template<typename U>
+    requires std::derived_from<U, T>
+    auto Maybe() {
+        struct Maybe {
+            U* Mes;
+            std::shared_ptr<char[]> RawData;
+
+            operator bool() const {
+                return Mes != nullptr;
+            }
+
+            TMessageHolder<U> Cast() {
+                if (Mes) {
+                    return TMessageHolder<U>(Mes, RawData);
+                }
+                throw std::bad_cast();
+            }
+        };
+
+        U* dst = Mes->Type == static_cast<uint32_t>(U::MessageType)
+            ? static_cast<U*>(dst)
+            : nullptr;
+
+        return Maybe {
+            .Mes = dst,
+            .RawData = RawData
+        };
+    }
+};
+
+template<typename T>
+requires std::derived_from<T, TMessage>
+T* NewMessage(uint32_t type, uint32_t len) {
+    char* data = new char[len];
+    T* mes = reinterpret_cast<T*>(data);
+    mes->Type = type;
+    mes->Len = len;
+    return mes;
+}
+
+template<typename T>
+requires std::derived_from<T, TMessage>
+TMessageHolder<T> NewHoldedMessage(uint32_t type, uint32_t len)
+{
+    T* mes = NewMessage<T>(type, len);
+    return TMessageHolder<T>(mes, std::shared_ptr<char[]>(reinterpret_cast<char*>(mes)));
+}

test/test_raft.cpp

@@ -1,3 +1,5 @@
+#include <messages.h>
+
 #include <stdarg.h>
 #include <stddef.h>
 #include <setjmp.h>
@@ -9,9 +11,26 @@ void test_empty(void** state) {
 
 }
 
+void test_message_create(void** state) {
+    auto mes = NewHoldedMessage<TMessage>(0, 4);
+    assert_true(mes->Len == 4);
+    assert_true(mes->Type == 0);
+}
+
+void test_message_cast(void** state) {
+    TMessageHolder<TMessage> mes = NewHoldedMessage<TLogEntry>(static_cast<uint32_t>(TLogEntry::MessageType), 4);
+    auto casted = mes.Cast<TLogEntry>();
+    assert_true(mes.RawData == casted.RawData);
+
+    auto casted2 = mes.Maybe<RequestVoteRequest>();
+    assert_false(casted2);
+}
+
 int main() {
     const struct CMUnitTest tests[] = {
         cmocka_unit_test(test_empty),
+        cmocka_unit_test(test_message_create),
+        cmocka_unit_test(test_message_cast),
     };
-    return 0;
+    return cmocka_run_group_tests(tests, NULL, NULL);
 }