diff --git a/.gitignore b/.gitignore index dc38d40b..63f8733d 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,5 @@ *~ libcraft.so libcraft.a +cmake-make +build diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..8ea8c1a0 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "thirdparty/gtest"] + path = thirdparty/gtest + url = https://github.com/CPB9/gtest +[submodule "thirdparty/linked-list-queue"] + path = thirdparty/linked-list-queue + url = https://github.com/willemt/linked-list-queue.git diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000..e5f278d7 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,28 @@ +project(craft) + +cmake_minimum_required(VERSION 2.8.11) + +add_subdirectory(thirdparty/gtest) +target_compile_options(gtest PUBLIC -DGTEST_HAS_TR1_TUPLE=0) +target_compile_options(gtest_main PUBLIC -DGTEST_HAS_TR1_TUPLE=0) + +add_library(craft STATIC + include/raft.h + include/raft_log.h + include/raft_private.h + src/raft_log.c + src/raft_node.c + src/raft_server.c + src/raft_server_properties.c +) +target_include_directories(craft PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include) + +add_library(linked-list-queue STATIC + thirdparty/linked-list-queue/linked_list_queue.h + thirdparty/linked-list-queue/linked_list_queue.c +) +target_include_directories(linked-list-queue PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) +set(LINKED_LIST_QUEUE_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/linked-list-queue) + +set(GTEST_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/gtest/include) +add_subdirectory(tests) diff --git a/src/raft_server.c b/src/raft_server.c index fad848e1..18aac3b7 100644 --- a/src/raft_server.c +++ b/src/raft_server.c @@ -209,6 +209,7 @@ int raft_periodic(raft_server_t* me_, int msec_since_last_period) /* Only one voting node means it's safe for us to become the leader */ if (1 == raft_get_num_voting_nodes(me_) && + raft_get_my_node(me_) && raft_node_is_voting(raft_get_my_node((void*)me)) && !raft_is_leader(me_)) raft_become_leader(me_); @@ -225,6 +226,7 @@ int raft_periodic(raft_server_t* me_, int msec_since_last_period) !raft_snapshot_is_in_progress(me_)) { if (1 < raft_get_num_voting_nodes(me_) && + raft_get_my_node(me_) && raft_node_is_voting(raft_get_my_node(me_))) { int e = raft_election_start(me_); @@ -833,7 +835,7 @@ int raft_send_appendentries(raft_server_t* me_, raft_node_t* node) if (!(me->cb.send_appendentries)) return -1; - msg_appendentries_t ae = {}; + msg_appendentries_t ae = {0}; ae.term = me->current_term; ae.leader_commit = raft_get_commit_idx(me_); ae.prev_log_idx = 0; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 00000000..6f7ee16d --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,51 @@ +include_directories( + ${RAFT_INCLUDE_DIRS} + SYSTEM + ${GTEST_INCLUDE_DIRS} + ${LINKED_LIST_QUEUE_INCLUDE_DIRS} +) + +add_definitions(-DDATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data") +set(TESTS_DIR ${CMAKE_BINARY_DIR}/bin/tests) +file(MAKE_DIRECTORY ${TESTS_DIR}) + +set(ALL_TESTS "") + +macro(add_unit_test test file) + add_executable(${test} ${file} mock_send_functions.c) + target_link_libraries(${test} + ${ARGN} + craft + linked-list-queue + gtest + gtest_main + ) + + set_target_properties(${test} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY ${TESTS_DIR} + FOLDER "tests" + ) + add_test(${test} ${TESTS_DIR}/${test}) + list(APPEND ALL_TESTS ${file}) +endmacro() + +add_unit_test(raft_log_tests test_log.cpp) +add_unit_test(raft_node_tests test_node.cpp) +add_unit_test(raft_scenario_tests test_scenario.cpp) +add_unit_test(raft_server_tests test_server.cpp) +add_unit_test(raft_snapshotting_tests test_snapshotting.cpp) + +add_executable(all_tests EXCLUDE_FROM_ALL ${ALL_TESTS} mock_send_functions.c) +target_link_libraries(all_tests + craft + linked-list-queue + gtest + gtest_main +) + +set_target_properties(all_tests + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY ${TESTS_DIR} + FOLDER "tests" +) diff --git a/tests/CuTest.c b/tests/CuTest.c deleted file mode 100644 index 6f003acf..00000000 --- a/tests/CuTest.c +++ /dev/null @@ -1,290 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#include "CuTest.h" - -/*-------------------------------------------------------------------------* - * CuStr - *-------------------------------------------------------------------------*/ - -char* CuStrAlloc(int size) -{ - char* newStr = (char*) malloc( sizeof(char) * (size) ); - return newStr; -} - -char* CuStrCopy(const char* old) -{ - int len = strlen(old); - char* newStr = CuStrAlloc(len + 1); - strcpy(newStr, old); - return newStr; -} - -/*-------------------------------------------------------------------------* - * CuString - *-------------------------------------------------------------------------*/ - -void CuStringInit(CuString* str) -{ - str->length = 0; - str->size = STRING_MAX; - str->buffer = (char*) malloc(sizeof(char) * str->size); - str->buffer[0] = '\0'; -} - -CuString* CuStringNew(void) -{ - CuString* str = (CuString*) malloc(sizeof(CuString)); - str->length = 0; - str->size = STRING_MAX; - str->buffer = (char*) malloc(sizeof(char) * str->size); - str->buffer[0] = '\0'; - return str; -} - -void CuStringResize(CuString* str, int newSize) -{ - str->buffer = (char*) realloc(str->buffer, sizeof(char) * newSize); - str->size = newSize; -} - -void CuStringAppend(CuString* str, const char* text) -{ - int length; - - if (text == NULL) { - text = "NULL"; - } - - length = strlen(text); - if (str->length + length + 1 >= str->size) - CuStringResize(str, str->length + length + 1 + STRING_INC); - str->length += length; - strcat(str->buffer, text); -} - -void CuStringAppendChar(CuString* str, char ch) -{ - char text[2]; - text[0] = ch; - text[1] = '\0'; - CuStringAppend(str, text); -} - -void CuStringAppendFormat(CuString* str, const char* format, ...) -{ - va_list argp; - char buf[HUGE_STRING_LEN]; - va_start(argp, format); - vsprintf(buf, format, argp); - va_end(argp); - CuStringAppend(str, buf); -} - -void CuStringInsert(CuString* str, const char* text, int pos) -{ - int length = strlen(text); - if (pos > str->length) - pos = str->length; - if (str->length + length + 1 >= str->size) - CuStringResize(str, str->length + length + 1 + STRING_INC); - memmove(str->buffer + pos + length, str->buffer + pos, (str->length - pos) + 1); - str->length += length; - memcpy(str->buffer + pos, text, length); -} - -/*-------------------------------------------------------------------------* - * CuTest - *-------------------------------------------------------------------------*/ - -void CuTestInit(CuTest* t, const char* name, TestFunction function) -{ - t->name = CuStrCopy(name); - t->failed = 0; - t->ran = 0; - t->message = NULL; - t->function = function; - t->jumpBuf = NULL; -} - -CuTest* CuTestNew(const char* name, TestFunction function) -{ - CuTest* tc = CU_ALLOC(CuTest); - CuTestInit(tc, name, function); - return tc; -} - -void CuTestRun(CuTest* tc) -{ -#if 0 /* debugging */ - printf(" running %s\n", tc->name); -#endif - jmp_buf buf; - tc->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - tc->ran = 1; - (tc->function)(tc); - } - tc->jumpBuf = 0; -} - -static void CuFailInternal(CuTest* tc, const char* file, int line, CuString* string) -{ - char buf[HUGE_STRING_LEN]; - - sprintf(buf, "%s:%d: ", file, line); - CuStringInsert(string, buf, 0); - - tc->failed = 1; - tc->message = string->buffer; - if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0); -} - -void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message) -{ - CuString string; - - CuStringInit(&string); - if (message2 != NULL) - { - CuStringAppend(&string, message2); - CuStringAppend(&string, ": "); - } - CuStringAppend(&string, message); - CuFailInternal(tc, file, line, &string); -} - -void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition) -{ - if (condition) return; - CuFail_Line(tc, file, line, NULL, message); -} - -void CuAssertStrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - const char* expected, const char* actual) -{ - CuString string; - if ((expected == NULL && actual == NULL) || - (expected != NULL && actual != NULL && - strcmp(expected, actual) == 0)) - { - return; - } - - CuStringInit(&string); - if (message != NULL) - { - CuStringAppend(&string, message); - CuStringAppend(&string, ": "); - } - CuStringAppend(&string, "expected <"); - CuStringAppend(&string, expected); - CuStringAppend(&string, "> but was <"); - CuStringAppend(&string, actual); - CuStringAppend(&string, ">"); - CuFailInternal(tc, file, line, &string); -} - -void CuAssertIntEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - int expected, int actual) -{ - char buf[STRING_MAX]; - if (expected == actual) return; - sprintf(buf, "expected <%d> but was <%d>", expected, actual); - CuFail_Line(tc, file, line, message, buf); -} - -void CuAssertDblEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - double expected, double actual, double delta) -{ - char buf[STRING_MAX]; - if (fabs(expected - actual) <= delta) return; - sprintf(buf, "expected <%lf> but was <%lf>", expected, actual); - CuFail_Line(tc, file, line, message, buf); -} - -void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - void* expected, void* actual) -{ - char buf[STRING_MAX]; - if (expected == actual) return; - sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual); - CuFail_Line(tc, file, line, message, buf); -} - - -/*-------------------------------------------------------------------------* - * CuSuite - *-------------------------------------------------------------------------*/ - -void CuSuiteInit(CuSuite* testSuite) -{ - testSuite->count = 0; - testSuite->failCount = 0; -} - -CuSuite* CuSuiteNew(void) -{ - CuSuite* testSuite = CU_ALLOC(CuSuite); - CuSuiteInit(testSuite); - return testSuite; -} - -void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase) -{ - assert(testSuite->count < MAX_TEST_CASES); - testSuite->list[testSuite->count] = testCase; - testSuite->count++; -} - -void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2) -{ - int i; - for (i = 0 ; i < testSuite2->count ; ++i) - { - CuTest* testCase = testSuite2->list[i]; - CuSuiteAdd(testSuite, testCase); - } -} - -void CuSuiteRun(CuSuite* testSuite) -{ - int i; - for (i = 0 ; i < testSuite->count ; ++i) - { - CuTest* testCase = testSuite->list[i]; - CuTestRun(testCase); - if (testCase->failed) { testSuite->failCount += 1; } - } -} - -void CuSuiteDetails(CuSuite* testSuite, CuString* details) -{ - int i; - int failCount = 0; - - CuStringAppendFormat(details, "%d..%d\n", 1, testSuite->count); - - for (i = 0 ; i < testSuite->count ; ++i) - { - CuTest* testCase = testSuite->list[i]; - - if (testCase->failed) - { - failCount++; - CuStringAppendFormat(details, "not ok %d - %s #%s\n", - i+1, testCase->name, testCase->message); - } - else - { - CuStringAppendFormat(details, "ok %d - %s\n", - i+1, testCase->name); - } - } -} diff --git a/tests/CuTest.h b/tests/CuTest.h deleted file mode 100644 index 78c41468..00000000 --- a/tests/CuTest.h +++ /dev/null @@ -1,111 +0,0 @@ -#ifndef CU_TEST_H -#define CU_TEST_H - -#include -#include - -/* CuString */ - -char* CuStrAlloc(int size); -char* CuStrCopy(const char* old); - -#define CU_ALLOC(TYPE) ((TYPE*) malloc(sizeof(TYPE))) - -#define HUGE_STRING_LEN 8192 -#define STRING_MAX 256 -#define STRING_INC 256 - -typedef struct -{ - int length; - int size; - char* buffer; -} CuString; - -void CuStringInit(CuString* str); -CuString* CuStringNew(void); -void CuStringRead(CuString* str, const char* path); -void CuStringAppend(CuString* str, const char* text); -void CuStringAppendChar(CuString* str, char ch); -void CuStringAppendFormat(CuString* str, const char* format, ...); -void CuStringInsert(CuString* str, const char* text, int pos); -void CuStringResize(CuString* str, int newSize); - -/* CuTest */ - -typedef struct CuTest CuTest; - -typedef void (*TestFunction)(CuTest *); - -struct CuTest -{ - const char* name; - TestFunction function; - int failed; - int ran; - const char* message; - jmp_buf *jumpBuf; -}; - -void CuTestInit(CuTest* t, const char* name, TestFunction function); -CuTest* CuTestNew(const char* name, TestFunction function); -void CuTestRun(CuTest* tc); - -/* Internal versions of assert functions -- use the public versions */ -void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message); -void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition); -void CuAssertStrEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - const char* expected, const char* actual); -void CuAssertIntEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - int expected, int actual); -void CuAssertDblEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - double expected, double actual, double delta); -void CuAssertPtrEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - void* expected, void* actual); - -/* public assert functions */ - -#define CuFail(tc, ms) CuFail_Line( (tc), __FILE__, __LINE__, NULL, (ms)) -#define CuAssert(tc, ms, cond) CuAssert_Line((tc), __FILE__, __LINE__, (ms), (cond)) -#define CuAssertTrue(tc, cond) CuAssert_Line((tc), __FILE__, __LINE__, "assert failed", (cond)) - -#define CuAssertStrEquals(tc,ex,ac) CuAssertStrEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac)) -#define CuAssertStrEquals_Msg(tc,ms,ex,ac) CuAssertStrEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac)) -#define CuAssertIntEquals(tc,ex,ac) CuAssertIntEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac)) -#define CuAssertIntEquals_Msg(tc,ms,ex,ac) CuAssertIntEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac)) -#define CuAssertDblEquals(tc,ex,ac,dl) CuAssertDblEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac),(dl)) -#define CuAssertDblEquals_Msg(tc,ms,ex,ac,dl) CuAssertDblEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac),(dl)) -#define CuAssertPtrEquals(tc,ex,ac) CuAssertPtrEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac)) -#define CuAssertPtrEquals_Msg(tc,ms,ex,ac) CuAssertPtrEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac)) - -#define CuAssertPtrNotNull(tc,p) CuAssert_Line((tc),__FILE__,__LINE__,"null pointer unexpected",(p != NULL)) -#define CuAssertPtrNotNullMsg(tc,msg,p) CuAssert_Line((tc),__FILE__,__LINE__,(msg),(p != NULL)) - -/* CuSuite */ - -#define MAX_TEST_CASES 1024 - -#define SUITE_ADD_TEST(SUITE,TEST) CuSuiteAdd(SUITE, CuTestNew(#TEST, TEST)) - -typedef struct -{ - int count; - CuTest* list[MAX_TEST_CASES]; - int failCount; - -} CuSuite; - - -void CuSuiteInit(CuSuite* testSuite); -CuSuite* CuSuiteNew(void); -void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase); -void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2); -void CuSuiteRun(CuSuite* testSuite); -void CuSuiteSummary(CuSuite* testSuite, CuString* summary); -void CuSuiteDetails(CuSuite* testSuite, CuString* details); - -#endif /* CU_TEST_H */ diff --git a/tests/make-tests.sh b/tests/make-tests.sh deleted file mode 100644 index bfab69c6..00000000 --- a/tests/make-tests.sh +++ /dev/null @@ -1,53 +0,0 @@ -#!/bin/bash - -# Auto generate single AllTests file for CuTest. -# Searches through all *.c files in the current directory. -# Prints to stdout. -# Author: Asim Jalis -# Date: 01/08/2003 - -FILES=*.c - -#if test $# -eq 0 ; then FILES=*.c ; else FILES=$* ; fi - -echo ' - -/* This is auto-generated code. Edit at your own peril. */ -#include -#include "CuTest.h" - -' - -cat $FILES | grep '^void Test' | - sed -e 's/(.*$//' \ - -e 's/$/(CuTest*);/' \ - -e 's/^/extern /' - -echo \ -' - -void RunAllTests(void) -{ - CuString *output = CuStringNew(); - CuSuite* suite = CuSuiteNew(); - -' -cat $FILES | grep '^void Test' | - sed -e 's/^void //' \ - -e 's/(.*$//' \ - -e 's/^/ SUITE_ADD_TEST(suite, /' \ - -e 's/$/);/' - -echo \ -' - CuSuiteRun(suite); - CuSuiteDetails(suite, output); - printf("%s\\n", output->buffer); -} - -int main() -{ - RunAllTests(); - return 0; -} -' diff --git a/tests/mock_send_functions.c b/tests/mock_send_functions.c index ce8ec7a9..7ac4808d 100644 --- a/tests/mock_send_functions.c +++ b/tests/mock_send_functions.c @@ -10,7 +10,6 @@ #include #include #include -#include "CuTest.h" #include "linked_list_queue.h" diff --git a/tests/test_log.c b/tests/test_log.c deleted file mode 100644 index a9244812..00000000 --- a/tests/test_log.c +++ /dev/null @@ -1,581 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include "CuTest.h" - -#include "linked_list_queue.h" - -#include "raft.h" -#include "raft_log.h" -#include "raft_private.h" - -static int __logentry_get_node_id( - raft_server_t* raft, - void *udata, - raft_entry_t *ety, - int ety_idx - ) -{ - return 0; -} - -static int __log_offer( - raft_server_t* raft, - void *user_data, - raft_entry_t *entry, - int entry_idx - ) -{ - CuAssertIntEquals((CuTest*)raft, 1, entry_idx); - return 0; -} - -static int __log_pop( - raft_server_t* raft, - void *user_data, - raft_entry_t *entry, - int entry_idx - ) -{ - raft_entry_t* copy = malloc(sizeof(*entry)); - memcpy(copy, entry, sizeof(*entry)); - llqueue_offer(user_data, copy); - return 0; -} - -static int __log_pop_failing( - raft_server_t* raft, - void *user_data, - raft_entry_t *entry, - int entry_idx - ) -{ - return -1; -} - -raft_cbs_t funcs = { - .log_pop = __log_pop, - .log_get_node_id = __logentry_get_node_id -}; - -void* __set_up() -{ - void* queue = llqueue_new(); - void *r = raft_new(); - raft_set_callbacks(r, &funcs, queue); - return r; -} - -void TestLog_new_is_empty(CuTest * tc) -{ - void *l; - - l = log_new(); - CuAssertTrue(tc, 0 == log_count(l)); -} - -void TestLog_append_is_not_empty(CuTest * tc) -{ - void *l; - raft_entry_t e; - - void *r = raft_new(); - - memset(&e, 0, sizeof(raft_entry_t)); - - e.id = 1; - - l = log_new(); - raft_cbs_t funcs = { - .log_offer = __log_offer - }; - log_set_callbacks(l, &funcs, r); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e)); - CuAssertIntEquals(tc, 1, log_count(l)); -} - -void TestLog_get_at_idx(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - l = log_new(); - e1.id = 1; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - e2.id = 2; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - e3.id = 3; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 3, log_count(l)); - CuAssertIntEquals(tc, e1.id, log_get_at_idx(l, 1)->id); - CuAssertIntEquals(tc, e2.id, log_get_at_idx(l, 2)->id); - CuAssertIntEquals(tc, e3.id, log_get_at_idx(l, 3)->id); -} - -void TestLog_get_at_idx_returns_null_where_out_of_bounds(CuTest * tc) -{ - void *l; - raft_entry_t e1; - - memset(&e1, 0, sizeof(raft_entry_t)); - - l = log_new(); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 0)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 1)); - - e1.id = 1; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 2)); -} - -void TestLog_delete(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3; - - void* queue = llqueue_new(); - void *r = raft_new(); - raft_cbs_t funcs = { - .log_pop = __log_pop, - .log_get_node_id = __logentry_get_node_id - }; - raft_set_callbacks(r, &funcs, queue); - - l = log_new(); - log_set_callbacks(l, &funcs, r); - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - e1.id = 1; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - e2.id = 2; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - e3.id = 3; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 3, log_count(l)); - CuAssertIntEquals(tc, 3, log_get_current_idx(l)); - - log_delete(l, 3); - CuAssertIntEquals(tc, 2, log_count(l)); - CuAssertIntEquals(tc, e3.id, ((raft_entry_t*)llqueue_poll(queue))->id); - CuAssertIntEquals(tc, 2, log_count(l)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 3)); - - log_delete(l, 2); - CuAssertIntEquals(tc, 1, log_count(l)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 2)); - - log_delete(l, 1); - CuAssertIntEquals(tc, 0, log_count(l)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 1)); -} - -void TestLog_delete_onwards(CuTest * tc) -{ - void* queue = llqueue_new(); - void *r = raft_new(); - raft_cbs_t funcs = { - .log_pop = __log_pop, - .log_get_node_id = __logentry_get_node_id - }; - raft_set_callbacks(r, &funcs, queue); - - void *l; - raft_entry_t e1, e2, e3; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - l = log_new(); - log_set_callbacks(l, &funcs, r); - e1.id = 1; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - e2.id = 2; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - e3.id = 3; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 3, log_count(l)); - - /* even 3 gets deleted */ - log_delete(l, 2); - CuAssertIntEquals(tc, 1, log_count(l)); - CuAssertIntEquals(tc, e1.id, log_get_at_idx(l, 1)->id); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 2)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 3)); -} - -void TestLog_delete_handles_log_pop_failure(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3; - - void* queue = llqueue_new(); - void *r = raft_new(); - raft_cbs_t funcs = { - .log_pop = __log_pop_failing, - .log_get_node_id = __logentry_get_node_id - }; - raft_set_callbacks(r, &funcs, queue); - - l = log_new(); - log_set_callbacks(l, &funcs, r); - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - e1.id = 1; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - e2.id = 2; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - e3.id = 3; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 3, log_count(l)); - CuAssertIntEquals(tc, 3, log_get_current_idx(l)); - - CuAssertIntEquals(tc, -1, log_delete(l, 3)); - CuAssertIntEquals(tc, 3, log_count(l)); - CuAssertIntEquals(tc, 3, log_count(l)); - CuAssertIntEquals(tc, e3.id, ((raft_entry_t*)log_peektail(l))->id); - } - -void TestLog_delete_fails_for_idx_zero(CuTest * tc) -{ - void* queue = llqueue_new(); - void *r = raft_new(); - raft_cbs_t funcs = { - .log_pop = __log_pop, - .log_get_node_id = __logentry_get_node_id - }; - raft_set_callbacks(r, &funcs, queue); - - void *l; - raft_entry_t e1, e2, e3, e4; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - memset(&e4, 0, sizeof(raft_entry_t)); - - e1.id = 1; - e2.id = 2; - e3.id = 3; - e4.id = 4; - - l = log_alloc(1); - log_set_callbacks(l, &funcs, r); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e4)); - CuAssertIntEquals(tc, log_delete(l, 0), -1); -} - -void TestLog_poll(CuTest * tc) -{ - void* queue = llqueue_new(); - void *r = raft_new(); - raft_cbs_t funcs = { - .log_pop = __log_pop, - .log_get_node_id = __logentry_get_node_id - }; - raft_set_callbacks(r, &funcs, queue); - - void *l; - raft_entry_t e1, e2, e3; - - l = log_new(); - log_set_callbacks(l, &funcs, r); - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - e1.id = 1; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - CuAssertIntEquals(tc, 1, log_get_current_idx(l)); - - e2.id = 2; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - CuAssertIntEquals(tc, 2, log_get_current_idx(l)); - - e3.id = 3; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 3, log_count(l)); - CuAssertIntEquals(tc, 3, log_get_current_idx(l)); - - raft_entry_t *ety; - - /* remove 1st */ - ety = NULL; - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertTrue(tc, NULL != ety); - CuAssertIntEquals(tc, 2, log_count(l)); - CuAssertIntEquals(tc, ety->id, 1); - CuAssertIntEquals(tc, 1, log_get_base(l)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 1)); - CuAssertTrue(tc, NULL != log_get_at_idx(l, 2)); - CuAssertTrue(tc, NULL != log_get_at_idx(l, 3)); - CuAssertIntEquals(tc, 3, log_get_current_idx(l)); - - /* remove 2nd */ - ety = NULL; - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertTrue(tc, NULL != ety); - CuAssertIntEquals(tc, 1, log_count(l)); - CuAssertIntEquals(tc, ety->id, 2); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 1)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 2)); - CuAssertTrue(tc, NULL != log_get_at_idx(l, 3)); - CuAssertIntEquals(tc, 3, log_get_current_idx(l)); - - /* remove 3rd */ - ety = NULL; - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertTrue(tc, NULL != ety); - CuAssertIntEquals(tc, 0, log_count(l)); - CuAssertIntEquals(tc, ety->id, 3); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 1)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 2)); - CuAssertTrue(tc, NULL == log_get_at_idx(l, 3)); - CuAssertIntEquals(tc, 3, log_get_current_idx(l)); -} - -void TestLog_peektail(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - l = log_new(); - e1.id = 1; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - e2.id = 2; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - e3.id = 3; - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 3, log_count(l)); - CuAssertIntEquals(tc, e3.id, log_peektail(l)->id); -} - -#if 0 -// TODO: duplicate testing not implemented yet -void T_estlog_cant_append_duplicates(CuTest * tc) -{ - void *l; - raft_entry_t e; - - e.id = 1; - - l = log_new(); - CuAssertTrue(tc, 1 == log_append_entry(l, &e)); - CuAssertTrue(tc, 1 == log_count(l)); -} -#endif - -void TestLog_load_from_snapshot(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - l = log_new(); - CuAssertIntEquals(tc, 0, log_get_current_idx(l)); - CuAssertIntEquals(tc, 0, log_load_from_snapshot(l, 10, 5)); - CuAssertIntEquals(tc, 10, log_get_current_idx(l)); - - /* this is just a marker - * it should never be sent to any nodes because it is part of a snapshot */ - CuAssertIntEquals(tc, 1, log_count(l)); -} - -void TestLog_load_from_snapshot_clears_log(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - l = log_new(); - - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - CuAssertIntEquals(tc, 2, log_count(l)); - CuAssertIntEquals(tc, 2, log_get_current_idx(l)); - - CuAssertIntEquals(tc, 0, log_load_from_snapshot(l, 10, 5)); - CuAssertIntEquals(tc, 1, log_count(l)); - CuAssertIntEquals(tc, 10, log_get_current_idx(l)); -} - -void TestLog_front_pushes_across_boundary(CuTest * tc) -{ - void* r = __set_up(); - - void *l; - raft_entry_t e1, e2, e3; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - - e1.id = 1; - e2.id = 2; - e3.id = 3; - - l = log_alloc(1); - log_set_callbacks(l, &funcs, r); - - raft_entry_t* ety; - - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertIntEquals(tc, ety->id, 1); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertIntEquals(tc, ety->id, 2); -} - -void TestLog_front_and_back_pushed_across_boundary_with_enlargement_required(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3, e4; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - memset(&e4, 0, sizeof(raft_entry_t)); - - e1.id = 1; - e2.id = 2; - e3.id = 3; - e4.id = 4; - - l = log_alloc(1); - - raft_entry_t* ety; - - /* append */ - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - - /* poll */ - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertIntEquals(tc, ety->id, 1); - - /* append */ - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - - /* poll */ - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertIntEquals(tc, ety->id, 2); - - /* append append */ - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e4)); - - /* poll */ - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertIntEquals(tc, ety->id, 3); -} - -void TestLog_delete_after_polling(CuTest * tc) -{ - void *l; - raft_entry_t e1, e2, e3, e4; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - memset(&e4, 0, sizeof(raft_entry_t)); - - e1.id = 1; - e2.id = 2; - e3.id = 3; - e4.id = 4; - - l = log_alloc(1); - - raft_entry_t* ety; - - /* append */ - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - CuAssertIntEquals(tc, 1, log_count(l)); - - /* poll */ - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertIntEquals(tc, ety->id, 1); - CuAssertIntEquals(tc, 0, log_count(l)); - - /* append */ - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - CuAssertIntEquals(tc, 1, log_count(l)); - - /* poll */ - CuAssertIntEquals(tc, log_delete(l, 1), 0); - CuAssertIntEquals(tc, 0, log_count(l)); -} - -void TestLog_delete_after_polling_from_double_append(CuTest * tc) -{ - void* queue = llqueue_new(); - void *r = raft_new(); - raft_cbs_t funcs = { - .log_pop = __log_pop, - .log_get_node_id = __logentry_get_node_id - }; - raft_set_callbacks(r, &funcs, queue); - - void *l; - raft_entry_t e1, e2, e3, e4; - - memset(&e1, 0, sizeof(raft_entry_t)); - memset(&e2, 0, sizeof(raft_entry_t)); - memset(&e3, 0, sizeof(raft_entry_t)); - memset(&e4, 0, sizeof(raft_entry_t)); - - e1.id = 1; - e2.id = 2; - e3.id = 3; - e4.id = 4; - - l = log_alloc(1); - log_set_callbacks(l, &funcs, r); - - raft_entry_t* ety; - - /* append append */ - CuAssertIntEquals(tc, 0, log_append_entry(l, &e1)); - CuAssertIntEquals(tc, 0, log_append_entry(l, &e2)); - CuAssertIntEquals(tc, 2, log_count(l)); - - /* poll */ - CuAssertIntEquals(tc, log_poll(l, (void*)&ety), 0); - CuAssertIntEquals(tc, ety->id, 1); - CuAssertIntEquals(tc, 1, log_count(l)); - - /* append */ - CuAssertIntEquals(tc, 0, log_append_entry(l, &e3)); - CuAssertIntEquals(tc, 2, log_count(l)); - - /* poll */ - CuAssertIntEquals(tc, log_delete(l, 1), 0); - CuAssertIntEquals(tc, 0, log_count(l)); -} diff --git a/tests/test_log.cpp b/tests/test_log.cpp new file mode 100644 index 00000000..07fc1494 --- /dev/null +++ b/tests/test_log.cpp @@ -0,0 +1,570 @@ +#include + +extern "C" +{ +#include "linked_list_queue.h" +#include "raft.h" +#include "raft_log.h" +#include "raft_private.h" +} + +static int __logentry_get_node_id( + raft_server_t* raft, + void *udata, + raft_entry_t *ety, + int ety_idx + ) +{ + return 0; +} + +static int __log_offer( + raft_server_t* raft, + void *user_data, + raft_entry_t *entry, + int entry_idx + ) +{ + EXPECT_EQ(1, entry_idx); + return 0; +} + +static int __log_pop( + raft_server_t* raft, + void *user_data, + raft_entry_t *entry, + int entry_idx + ) +{ + raft_entry_t* copy = (raft_entry_t*)malloc(sizeof(*entry)); + memcpy(copy, entry, sizeof(*entry)); + llqueue_offer((linked_list_queue_t*)user_data, copy); + return 0; +} + +static int __log_pop_failing( + raft_server_t* raft, + void *user_data, + raft_entry_t *entry, + int entry_idx + ) +{ + return -1; +} + + +TEST(TestLog, new_is_empty) +{ + log_t* l; + + l = log_new(); + EXPECT_EQ(0, log_count(l)); +} + +TEST(TestLog, append_is_not_empty) +{ + log_t* l; + raft_entry_t e; + + raft_server_t *r = raft_new(); + + memset(&e, 0, sizeof(raft_entry_t)); + + e.id = 1; + + l = log_new(); + raft_cbs_t funcs = {0}; + funcs.log_offer = __log_offer; + + log_set_callbacks(l, &funcs, r); + EXPECT_EQ(0, log_append_entry(l, &e)); + EXPECT_EQ(1, log_count(l)); +} + +TEST(TestLog, get_at_idx) +{ + log_t *l; + raft_entry_t e1, e2, e3; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + l = log_new(); + e1.id = 1; + EXPECT_EQ(0, log_append_entry(l, &e1)); + e2.id = 2; + EXPECT_EQ(0, log_append_entry(l, &e2)); + e3.id = 3; + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(3, log_count(l)); + EXPECT_EQ(e1.id, log_get_at_idx(l, 1)->id); + EXPECT_EQ(e2.id, log_get_at_idx(l, 2)->id); + EXPECT_EQ(e3.id, log_get_at_idx(l, 3)->id); +} + +TEST(TestLog, get_at_idx_returns_null_where_out_of_bounds) +{ + log_t *l; + raft_entry_t e1; + + memset(&e1, 0, sizeof(raft_entry_t)); + + l = log_new(); + EXPECT_EQ(NULL, log_get_at_idx(l, 0)); + EXPECT_EQ(NULL, log_get_at_idx(l, 1)); + + e1.id = 1; + EXPECT_EQ(0, log_append_entry(l, &e1)); + EXPECT_EQ(NULL, log_get_at_idx(l, 2)); +} + +TEST(TestLog, _delete) +{ + log_t *l; + raft_entry_t e1, e2, e3; + + linked_list_queue_t* queue = (linked_list_queue_t*)llqueue_new(); + raft_server_t *r = raft_new(); + raft_cbs_t funcs = {0}; + funcs.log_pop = __log_pop; + funcs.log_get_node_id = __logentry_get_node_id; + + raft_set_callbacks(r, &funcs, queue); + + l = log_new(); + log_set_callbacks(l, &funcs, r); + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + e1.id = 1; + EXPECT_EQ(0, log_append_entry(l, &e1)); + e2.id = 2; + EXPECT_EQ(0, log_append_entry(l, &e2)); + e3.id = 3; + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(3, log_count(l)); + EXPECT_EQ(3, log_get_current_idx(l)); + + log_delete(l, 3); + EXPECT_EQ(2, log_count(l)); + EXPECT_EQ(e3.id, ((raft_entry_t*)llqueue_poll(queue))->id); + EXPECT_EQ(2, log_count(l)); + EXPECT_EQ(NULL, log_get_at_idx(l, 3)); + + log_delete(l, 2); + EXPECT_EQ(1, log_count(l)); + EXPECT_EQ(NULL, log_get_at_idx(l, 2)); + + log_delete(l, 1); + EXPECT_EQ(0, log_count(l)); + EXPECT_EQ(NULL, log_get_at_idx(l, 1)); +} + +TEST(TestLog, delete_onwards) +{ + linked_list_queue_t* queue = (linked_list_queue_t*)llqueue_new(); + raft_server_t *r = raft_new(); + raft_cbs_t funcs = { 0 }; + funcs.log_pop = __log_pop; + funcs.log_get_node_id = __logentry_get_node_id; + + raft_set_callbacks(r, &funcs, queue); + + log_t *l; + raft_entry_t e1, e2, e3; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + l = log_new(); + log_set_callbacks(l, &funcs, r); + e1.id = 1; + EXPECT_EQ(0, log_append_entry(l, &e1)); + e2.id = 2; + EXPECT_EQ(0, log_append_entry(l, &e2)); + e3.id = 3; + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(3, log_count(l)); + + /* even 3 gets deleted */ + log_delete(l, 2); + EXPECT_EQ(1, log_count(l)); + EXPECT_EQ(e1.id, log_get_at_idx(l, 1)->id); + EXPECT_EQ(NULL, log_get_at_idx(l, 2)); + EXPECT_EQ(NULL, log_get_at_idx(l, 3)); +} + +TEST(TestLog, delete_handles_log_pop_failure) +{ + log_t *l; + raft_entry_t e1, e2, e3; + + linked_list_queue_t* queue = (linked_list_queue_t*)llqueue_new(); + raft_server_t *r = raft_new(); + raft_cbs_t funcs = {0}; + funcs.log_pop = __log_pop_failing; + funcs.log_get_node_id = __logentry_get_node_id; + + raft_set_callbacks(r, &funcs, queue); + + l = log_new(); + log_set_callbacks(l, &funcs, r); + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + e1.id = 1; + EXPECT_EQ(0, log_append_entry(l, &e1)); + e2.id = 2; + EXPECT_EQ(0, log_append_entry(l, &e2)); + e3.id = 3; + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(3, log_count(l)); + EXPECT_EQ(3, log_get_current_idx(l)); + + EXPECT_EQ(-1, log_delete(l, 3)); + EXPECT_EQ(3, log_count(l)); + EXPECT_EQ(3, log_count(l)); + EXPECT_EQ(e3.id, ((raft_entry_t*)log_peektail(l))->id); + } + +TEST(TestLog, delete_fails_for_idx_zero) +{ + linked_list_queue_t* queue = (linked_list_queue_t*)llqueue_new(); + raft_server_t *r = raft_new(); + raft_cbs_t funcs = {0}; + funcs.log_pop = __log_pop; + funcs.log_get_node_id = __logentry_get_node_id; + + raft_set_callbacks(r, &funcs, queue); + + log_t *l; + raft_entry_t e1, e2, e3, e4; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + memset(&e4, 0, sizeof(raft_entry_t)); + + e1.id = 1; + e2.id = 2; + e3.id = 3; + e4.id = 4; + + l = log_alloc(1); + log_set_callbacks(l, &funcs, r); + EXPECT_EQ(0, log_append_entry(l, &e1)); + EXPECT_EQ(0, log_append_entry(l, &e2)); + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(0, log_append_entry(l, &e4)); + EXPECT_EQ(log_delete(l, 0), -1); +} + +TEST(TestLog, poll) +{ + linked_list_queue_t* queue = (linked_list_queue_t*)llqueue_new(); + raft_server_t *r = raft_new(); + raft_cbs_t funcs = {0}; + funcs.log_pop = __log_pop; + funcs.log_get_node_id = __logentry_get_node_id; + + raft_set_callbacks(r, &funcs, queue); + + log_t *l; + raft_entry_t e1, e2, e3; + + l = log_new(); + log_set_callbacks(l, &funcs, r); + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + e1.id = 1; + EXPECT_EQ(0, log_append_entry(l, &e1)); + EXPECT_EQ(1, log_get_current_idx(l)); + + e2.id = 2; + EXPECT_EQ(0, log_append_entry(l, &e2)); + EXPECT_EQ(2, log_get_current_idx(l)); + + e3.id = 3; + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(3, log_count(l)); + EXPECT_EQ(3, log_get_current_idx(l)); + + raft_entry_t *ety; + + /* remove 1st */ + ety = nullptr; + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_NE(nullptr, ety); + EXPECT_EQ(2, log_count(l)); + EXPECT_EQ(ety->id, 1); + EXPECT_EQ(1, log_get_base(l)); + EXPECT_EQ(nullptr, log_get_at_idx(l, 1)); + EXPECT_NE(nullptr, log_get_at_idx(l, 2)); + EXPECT_NE(nullptr, log_get_at_idx(l, 3)); + EXPECT_EQ(3, log_get_current_idx(l)); + + /* remove 2nd */ + ety = nullptr; + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_NE(nullptr, ety); + EXPECT_EQ(1, log_count(l)); + EXPECT_EQ(ety->id, 2); + EXPECT_EQ(nullptr, log_get_at_idx(l, 1)); + EXPECT_EQ(nullptr, log_get_at_idx(l, 2)); + EXPECT_NE(nullptr, log_get_at_idx(l, 3)); + EXPECT_EQ(3, log_get_current_idx(l)); + + /* remove 3rd */ + ety = nullptr; + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_NE(nullptr, ety); + EXPECT_EQ(0, log_count(l)); + EXPECT_EQ(ety->id, 3); + EXPECT_EQ(nullptr, log_get_at_idx(l, 1)); + EXPECT_EQ(nullptr, log_get_at_idx(l, 2)); + EXPECT_EQ(nullptr, log_get_at_idx(l, 3)); + EXPECT_EQ(3, log_get_current_idx(l)); +} + +TEST(TestLog, peektail) +{ + log_t *l; + raft_entry_t e1, e2, e3; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + l = log_new(); + e1.id = 1; + EXPECT_EQ(0, log_append_entry(l, &e1)); + e2.id = 2; + EXPECT_EQ(0, log_append_entry(l, &e2)); + e3.id = 3; + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(3, log_count(l)); + EXPECT_EQ(e3.id, log_peektail(l)->id); +} + +#if 0 +// TODO: duplicate testing not implemented yet +void T_estlog_cant_append_duplicates(CuTest * tc) +{ + void *l; + raft_entry_t e; + + e.id = 1; + + l = log_new(); + CuAssertTrue(tc, 1 == log_append_entry(l, &e)); + CuAssertTrue(tc, 1 == log_count(l)); +} +#endif + +TEST(TestLog, load_from_snapshot) +{ + log_t *l; + raft_entry_t e1, e2, e3; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + l = log_new(); + EXPECT_EQ(0, log_get_current_idx(l)); + EXPECT_EQ(0, log_load_from_snapshot(l, 10, 5)); + EXPECT_EQ(10, log_get_current_idx(l)); + + /* this is just a marker + * it should never be sent to any nodes because it is part of a snapshot */ + EXPECT_EQ(1, log_count(l)); +} + +TEST(TestLog, load_from_snapshot_clears_log) +{ + log_t *l; + raft_entry_t e1, e2, e3; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + l = log_new(); + + EXPECT_EQ(0, log_append_entry(l, &e1)); + EXPECT_EQ(0, log_append_entry(l, &e2)); + EXPECT_EQ(2, log_count(l)); + EXPECT_EQ(2, log_get_current_idx(l)); + + EXPECT_EQ(0, log_load_from_snapshot(l, 10, 5)); + EXPECT_EQ(1, log_count(l)); + EXPECT_EQ(10, log_get_current_idx(l)); +} + +TEST(TestLog, front_pushes_across_boundary) +{ + raft_cbs_t funcs = {0}; + funcs.log_pop = __log_pop; + funcs.log_get_node_id = __logentry_get_node_id; + + linked_list_queue_t* queue = (linked_list_queue_t*)llqueue_new(); + raft_server_t *r = raft_new(); + raft_set_callbacks(r, &funcs, queue); + + log_t *l; + raft_entry_t e1, e2, e3; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + + e1.id = 1; + e2.id = 2; + e3.id = 3; + + l = log_alloc(1); + log_set_callbacks(l, &funcs, r); + + raft_entry_t* ety; + + EXPECT_EQ(0, log_append_entry(l, &e1)); + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_EQ(ety->id, 1); + EXPECT_EQ(0, log_append_entry(l, &e2)); + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_EQ(ety->id, 2); +} + +TEST(TestLog, front_and_back_pushed_across_boundary_with_enlargement_required) +{ + log_t *l; + raft_entry_t e1, e2, e3, e4; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + memset(&e4, 0, sizeof(raft_entry_t)); + + e1.id = 1; + e2.id = 2; + e3.id = 3; + e4.id = 4; + + l = log_alloc(1); + + raft_entry_t* ety; + + /* append */ + EXPECT_EQ(0, log_append_entry(l, &e1)); + + /* poll */ + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_EQ(ety->id, 1); + + /* append */ + EXPECT_EQ(0, log_append_entry(l, &e2)); + + /* poll */ + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_EQ(ety->id, 2); + + /* append append */ + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(0, log_append_entry(l, &e4)); + + /* poll */ + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_EQ(ety->id, 3); +} + +TEST(TestLog, delete_after_polling) +{ + log_t *l; + raft_entry_t e1, e2, e3, e4; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + memset(&e4, 0, sizeof(raft_entry_t)); + + e1.id = 1; + e2.id = 2; + e3.id = 3; + e4.id = 4; + + l = log_alloc(1); + + raft_entry_t* ety; + + /* append */ + EXPECT_EQ(0, log_append_entry(l, &e1)); + EXPECT_EQ(1, log_count(l)); + + /* poll */ + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_EQ(ety->id, 1); + EXPECT_EQ(0, log_count(l)); + + /* append */ + EXPECT_EQ(0, log_append_entry(l, &e2)); + EXPECT_EQ(1, log_count(l)); + + /* poll */ + EXPECT_EQ(log_delete(l, 1), 0); + EXPECT_EQ(0, log_count(l)); +} + +TEST(TestLog, delete_after_polling_from_double_append) +{ + linked_list_queue_t* queue = (linked_list_queue_t*)llqueue_new(); + raft_server_t *r = raft_new(); + raft_cbs_t funcs = {0}; + funcs.log_pop = __log_pop; + funcs.log_get_node_id = __logentry_get_node_id; + raft_set_callbacks(r, &funcs, queue); + + log_t *l; + raft_entry_t e1, e2, e3, e4; + + memset(&e1, 0, sizeof(raft_entry_t)); + memset(&e2, 0, sizeof(raft_entry_t)); + memset(&e3, 0, sizeof(raft_entry_t)); + memset(&e4, 0, sizeof(raft_entry_t)); + + e1.id = 1; + e2.id = 2; + e3.id = 3; + e4.id = 4; + + l = log_alloc(1); + log_set_callbacks(l, &funcs, r); + + raft_entry_t* ety; + + /* append append */ + EXPECT_EQ(0, log_append_entry(l, &e1)); + EXPECT_EQ(0, log_append_entry(l, &e2)); + EXPECT_EQ(2, log_count(l)); + + /* poll */ + EXPECT_EQ(log_poll(l, (void**)&ety), 0); + EXPECT_EQ(ety->id, 1); + EXPECT_EQ(1, log_count(l)); + + /* append */ + EXPECT_EQ(0, log_append_entry(l, &e3)); + EXPECT_EQ(2, log_count(l)); + + /* poll */ + EXPECT_EQ(log_delete(l, 1), 0); + EXPECT_EQ(0, log_count(l)); +} diff --git a/tests/test_node.c b/tests/test_node.c deleted file mode 100644 index eee28858..00000000 --- a/tests/test_node.c +++ /dev/null @@ -1,24 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include "CuTest.h" - -#include "raft.h" -#include "raft_log.h" -#include "raft_private.h" - -void TestRaft_is_voting_by_default(CuTest * tc) -{ - raft_node_t *p = raft_node_new((void*)1, 1); - CuAssertTrue(tc, raft_node_is_voting(p)); -} - -void TestRaft_node_set_nextIdx(CuTest * tc) -{ - raft_node_t *p = raft_node_new((void*)1, 1); - raft_node_set_next_idx(p, 3); - CuAssertTrue(tc, 3 == raft_node_get_next_idx(p)); -} diff --git a/tests/test_node.cpp b/tests/test_node.cpp new file mode 100644 index 00000000..15191d00 --- /dev/null +++ b/tests/test_node.cpp @@ -0,0 +1,19 @@ +#include +extern "C" +{ +#include "raft.h" +#include "raft_private.h" +} + +TEST(TestNode, is_voting_by_default) +{ + raft_node_t *p = raft_node_new((void*)1, 1); + EXPECT_TRUE(raft_node_is_voting(p)); +} + +TEST(TestNode, node_set_nextIdx) +{ + raft_node_t *p = raft_node_new((void*)1, 1); + raft_node_set_next_idx(p, 3); + EXPECT_EQ(3, raft_node_get_next_idx(p)); +} diff --git a/tests/test_scenario.c b/tests/test_scenario.cpp similarity index 65% rename from tests/test_scenario.c rename to tests/test_scenario.cpp index 142d461a..ecc2d8fe 100644 --- a/tests/test_scenario.c +++ b/tests/test_scenario.cpp @@ -1,15 +1,11 @@ -#include -#include -#include -#include -#include -#include -#include "CuTest.h" - +#include +extern "C" +{ #include "raft.h" #include "raft_log.h" #include "raft_private.h" #include "mock_send_functions.h" +} static int __raft_persist_term( raft_server_t* raft, @@ -30,12 +26,18 @@ static int __raft_persist_vote( return 0; } -void TestRaft_scenario_leader_appears(CuTest * tc) +TEST(TestScenario, leader_appears) { unsigned long i, j; raft_server_t *r[3]; void* sender[3]; + raft_cbs_t funcs = { 0 }; + funcs.send_requestvote = sender_requestvote; + funcs.send_appendentries = sender_appendentries; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + senders_new(); for (j = 0; j < 3; j++) @@ -49,14 +51,7 @@ void TestRaft_scenario_leader_appears(CuTest * tc) raft_add_node(r[j], sender[0], 1, j==0); raft_add_node(r[j], sender[1], 2, j==1); raft_add_node(r[j], sender[2], 3, j==2); - raft_set_callbacks(r[j], - &((raft_cbs_t) { - .send_requestvote = sender_requestvote, - .send_appendentries = sender_appendentries, - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .log = NULL - }), sender[j]); + raft_set_callbacks(r[j], &funcs, sender[j]); } /* NOTE: important for 1st node to send vote request before others */ @@ -82,6 +77,6 @@ void TestRaft_scenario_leader_appears(CuTest * tc) if (raft_is_leader(r[j])) leaders += 1; - CuAssertTrue(tc, 0 != leaders); - CuAssertTrue(tc, 1 == leaders); + EXPECT_NE(0, leaders); + EXPECT_EQ(1, leaders); } diff --git a/tests/test_server.c b/tests/test_server.cpp similarity index 58% rename from tests/test_server.c rename to tests/test_server.cpp index eb489a6b..8def08b0 100644 --- a/tests/test_server.c +++ b/tests/test_server.cpp @@ -1,17 +1,11 @@ - -#include -#include -#include -#include -#include -#include -#include "CuTest.h" - +#include +extern "C" +{ #include "raft.h" #include "raft_log.h" #include "raft_private.h" #include "mock_send_functions.h" - +} // TODO: leader doesn't timeout and cause election static int __raft_persist_term( @@ -59,6 +53,14 @@ static int __raft_send_appendentries(raft_server_t* raft, return 0; } +raft_cbs_t generic_funcs() +{ + raft_cbs_t f = {0}; + f.persist_term = __raft_persist_term; + f.persist_vote = __raft_persist_vote; + return f; +}; + static int __raft_node_has_sufficient_logs( raft_server_t* raft, void *user_data, @@ -69,165 +71,160 @@ static int __raft_node_has_sufficient_logs( return 0; } -raft_cbs_t generic_funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, -}; - static int max_election_timeout(int election_timeout) { - return 2 * election_timeout; + return 2 * election_timeout; } -void TestRaft_server_voted_for_records_who_we_voted_for(CuTest * tc) +TEST(TestServer, voted_for_records_who_we_voted_for) { - void *r = raft_new(); - raft_set_callbacks(r, &generic_funcs, NULL); + raft_server_t *r = raft_new(); + raft_set_callbacks(r, &generic_funcs(), NULL); raft_add_node(r, NULL, 2, 0); raft_vote(r, raft_get_node(r, 2)); - CuAssertTrue(tc, 2 == raft_get_voted_for(r)); + EXPECT_EQ(2, raft_get_voted_for(r)); } -void TestRaft_server_get_my_node(CuTest * tc) +TEST(TestServer, get_my_node) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_node_t* me = raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); - CuAssertTrue(tc, me == raft_get_my_node(r)); + EXPECT_EQ(me, raft_get_my_node(r)); } -void TestRaft_server_idx_starts_at_1(CuTest * tc) +TEST(TestServer, idx_starts_at_1) { - void *r = raft_new(); - CuAssertTrue(tc, 0 == raft_get_current_idx(r)); + raft_server_t *r = raft_new(); + EXPECT_EQ(0, raft_get_current_idx(r)); - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.data.buf = "aaa"; ety.data.len = 3; ety.id = 1; ety.term = 1; raft_append_entry(r, &ety); - CuAssertTrue(tc, 1 == raft_get_current_idx(r)); + EXPECT_EQ(1, raft_get_current_idx(r)); } -void TestRaft_server_currentterm_defaults_to_0(CuTest * tc) +TEST(TestServer, currentterm_defaults_to_0) { - void *r = raft_new(); - CuAssertTrue(tc, 0 == raft_get_current_term(r)); + raft_server_t *r = raft_new(); + EXPECT_EQ(0, raft_get_current_term(r)); } -void TestRaft_server_set_currentterm_sets_term(CuTest * tc) +TEST(TestServer, set_currentterm_sets_term) { - void *r = raft_new(); - raft_set_callbacks(r, &generic_funcs, NULL); + raft_server_t *r = raft_new(); + raft_set_callbacks(r, &generic_funcs(), NULL); raft_set_current_term(r, 5); - CuAssertTrue(tc, 5 == raft_get_current_term(r)); + EXPECT_EQ(5, raft_get_current_term(r)); } -void TestRaft_server_voting_results_in_voting(CuTest * tc) +TEST(TestServer, voting_results_in_voting) { - void *r = raft_new(); - raft_set_callbacks(r, &generic_funcs, NULL); + raft_server_t *r = raft_new(); + raft_set_callbacks(r, &generic_funcs(), NULL); raft_add_node(r, NULL, 1, 0); raft_add_node(r, NULL, 9, 0); raft_vote(r, raft_get_node(r, 1)); - CuAssertTrue(tc, 1 == raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); raft_vote(r, raft_get_node(r, 9)); - CuAssertTrue(tc, 9 == raft_get_voted_for(r)); + EXPECT_EQ(9, raft_get_voted_for(r)); } -void TestRaft_server_add_node_makes_non_voting_node_voting(CuTest * tc) +TEST(TestServer, add_node_makes_non_voting_node_voting) { - void *r = raft_new(); - void* n1 = raft_add_non_voting_node(r, NULL, 9, 0); + raft_server_t *r = raft_new(); + raft_node_t* n1 = raft_add_non_voting_node(r, NULL, 9, 0); - CuAssertTrue(tc, !raft_node_is_voting(n1)); + EXPECT_FALSE(raft_node_is_voting(n1)); raft_add_node(r, NULL, 9, 0); - CuAssertTrue(tc, raft_node_is_voting(n1)); - CuAssertIntEquals(tc, 1, raft_get_num_nodes(r)); + EXPECT_TRUE(raft_node_is_voting(n1)); + EXPECT_EQ(1, raft_get_num_nodes(r)); } -void TestRaft_server_add_node_with_already_existing_id_is_not_allowed(CuTest * tc) +TEST(TestServer, add_node_with_already_existing_id_is_not_allowed) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 9, 0); raft_add_node(r, NULL, 11, 0); - CuAssertTrue(tc, NULL == raft_add_node(r, NULL, 9, 0)); - CuAssertTrue(tc, NULL == raft_add_node(r, NULL, 11, 0)); + EXPECT_EQ(nullptr, raft_add_node(r, NULL, 9, 0)); + EXPECT_EQ(nullptr, raft_add_node(r, NULL, 11, 0)); } -void TestRaft_server_add_non_voting_node_with_already_existing_id_is_not_allowed(CuTest * tc) +TEST(TestServer, add_non_voting_node_with_already_existing_id_is_not_allowed) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_non_voting_node(r, NULL, 9, 0); raft_add_non_voting_node(r, NULL, 11, 0); - CuAssertTrue(tc, NULL == raft_add_non_voting_node(r, NULL, 9, 0)); - CuAssertTrue(tc, NULL == raft_add_non_voting_node(r, NULL, 11, 0)); + EXPECT_EQ(nullptr, raft_add_non_voting_node(r, NULL, 9, 0)); + EXPECT_EQ(nullptr, raft_add_non_voting_node(r, NULL, 11, 0)); } -void TestRaft_server_add_non_voting_node_with_already_existing_voting_id_is_not_allowed(CuTest * tc) +TEST(TestServer, add_non_voting_node_with_already_existing_voting_id_is_not_allowed) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 9, 0); raft_add_node(r, NULL, 11, 0); - CuAssertTrue(tc, NULL == raft_add_non_voting_node(r, NULL, 9, 0)); - CuAssertTrue(tc, NULL == raft_add_non_voting_node(r, NULL, 11, 0)); + EXPECT_EQ(nullptr, raft_add_non_voting_node(r, NULL, 9, 0)); + EXPECT_EQ(nullptr, raft_add_non_voting_node(r, NULL, 11, 0)); } -void TestRaft_server_remove_node(CuTest * tc) +TEST(TestServer, remove_node) { - void *r = raft_new(); - void* n1 = raft_add_node(r, NULL, 1, 0); - void* n2 = raft_add_node(r, NULL, 9, 0); + raft_server_t *r = raft_new(); + raft_node_t* n1 = raft_add_node(r, NULL, 1, 0); + raft_node_t* n2 = raft_add_node(r, NULL, 9, 0); raft_remove_node(r, n1); - CuAssertTrue(tc, NULL == raft_get_node(r, 1)); - CuAssertTrue(tc, NULL != raft_get_node(r, 9)); + EXPECT_EQ(nullptr, raft_get_node(r, 1)); + EXPECT_NE(nullptr, raft_get_node(r, 9)); raft_remove_node(r, n2); - CuAssertTrue(tc, NULL == raft_get_node(r, 9)); + EXPECT_EQ(nullptr, raft_get_node(r, 9)); } -void TestRaft_election_start_increments_term(CuTest * tc) +TEST(TestServer, election_start_increments_term) { - void *r = raft_new(); - raft_set_callbacks(r, &generic_funcs, NULL); + raft_server_t *r = raft_new(); + raft_set_callbacks(r, &generic_funcs(), NULL); raft_set_current_term(r, 1); raft_election_start(r); - CuAssertTrue(tc, 2 == raft_get_current_term(r)); + EXPECT_EQ(2, raft_get_current_term(r)); } -void TestRaft_set_state(CuTest * tc) +TEST(TestServer, set_state) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_state(r, RAFT_STATE_LEADER); - CuAssertTrue(tc, RAFT_STATE_LEADER == raft_get_state(r)); + EXPECT_EQ(RAFT_STATE_LEADER, raft_get_state(r)); } -void TestRaft_server_starts_as_follower(CuTest * tc) +TEST(TestServer, starts_as_follower) { - void *r = raft_new(); - CuAssertTrue(tc, RAFT_STATE_FOLLOWER == raft_get_state(r)); + raft_server_t *r = raft_new(); + EXPECT_EQ(RAFT_STATE_FOLLOWER, raft_get_state(r)); } -void TestRaft_server_starts_with_election_timeout_of_1000ms(CuTest * tc) +TEST(TestServer, starts_with_election_timeout_of_1000ms) { - void *r = raft_new(); - CuAssertTrue(tc, 1000 == raft_get_election_timeout(r)); + raft_server_t *r = raft_new(); + EXPECT_EQ(1000, raft_get_election_timeout(r)); } -void TestRaft_server_starts_with_request_timeout_of_200ms(CuTest * tc) +TEST(TestServer, starts_with_request_timeout_of_200ms) { - void *r = raft_new(); - CuAssertTrue(tc, 200 == raft_get_request_timeout(r)); + raft_server_t *r = raft_new(); + EXPECT_EQ(200, raft_get_request_timeout(r)); } -void TestRaft_server_entry_append_increases_logidx(CuTest* tc) +TEST(TestServer, entry_append_increases_logidx) { - raft_entry_t ety = {}; + raft_entry_t ety = {0}; char *str = "aaa"; ety.data.buf = str; @@ -235,15 +232,15 @@ void TestRaft_server_entry_append_increases_logidx(CuTest* tc) ety.id = 1; ety.term = 1; - void *r = raft_new(); - CuAssertTrue(tc, 0 == raft_get_current_idx(r)); + raft_server_t *r = raft_new(); + EXPECT_EQ(0, raft_get_current_idx(r)); raft_append_entry(r, &ety); - CuAssertTrue(tc, 1 == raft_get_current_idx(r)); + EXPECT_EQ(1, raft_get_current_idx(r)); } -void TestRaft_server_append_entry_means_entry_gets_current_term(CuTest* tc) +TEST(TestServer, append_entry_means_entry_gets_current_term) { - raft_entry_t ety = {}; + raft_entry_t ety = {0}; char *str = "aaa"; ety.data.buf = str; @@ -251,20 +248,20 @@ void TestRaft_server_append_entry_means_entry_gets_current_term(CuTest* tc) ety.id = 1; ety.term = 1; - void *r = raft_new(); - CuAssertTrue(tc, 0 == raft_get_current_idx(r)); + raft_server_t *r = raft_new(); + EXPECT_EQ(0, raft_get_current_idx(r)); raft_append_entry(r, &ety); - CuAssertTrue(tc, 1 == raft_get_current_idx(r)); + EXPECT_EQ(1, raft_get_current_idx(r)); } -void TestRaft_server_append_entry_is_retrievable(CuTest * tc) +TEST(TestServer, append_entry_is_retrievable) { - void *r = raft_new(); - raft_set_callbacks(r, &generic_funcs, NULL); + raft_server_t *r = raft_new(); + raft_set_callbacks(r, &generic_funcs(), NULL); raft_set_state(r, RAFT_STATE_CANDIDATE); raft_set_current_term(r, 5); - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 100; ety.data.len = 4; @@ -272,9 +269,9 @@ void TestRaft_server_append_entry_is_retrievable(CuTest * tc) raft_append_entry(r, &ety); raft_entry_t* kept = raft_get_entry_from_idx(r, 1); - CuAssertTrue(tc, NULL != kept->data.buf); - CuAssertIntEquals(tc, ety.data.len, kept->data.len); - CuAssertTrue(tc, kept->data.buf == ety.data.buf); + EXPECT_NE(nullptr, kept->data.buf); + EXPECT_EQ(ety.data.len, kept->data.len); + EXPECT_EQ(kept->data.buf, ety.data.buf); } static int __raft_logentry_offer( @@ -284,35 +281,34 @@ static int __raft_logentry_offer( int ety_idx ) { - CuAssertIntEquals(udata, ety_idx, 1); + EXPECT_EQ(ety_idx, 1); ety->data.buf = udata; return 0; } -void TestRaft_server_append_entry_user_can_set_data_buf(CuTest * tc) +TEST(TestServer, append_entry_user_can_set_data_buf) { - raft_cbs_t funcs = { - .log_offer = __raft_logentry_offer, - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = { 0 }; + funcs.log_offer = __raft_logentry_offer; + funcs.persist_term = __raft_persist_term; char *buf = "aaa"; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_state(r, RAFT_STATE_CANDIDATE); - raft_set_callbacks(r, &funcs, tc); + raft_set_callbacks(r, &funcs, r); raft_set_current_term(r, 5); - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 100; ety.data.len = 4; ety.data.buf = buf; raft_append_entry(r, &ety); /* User's input entry is intact. */ - CuAssertTrue(tc, ety.data.buf == buf); + EXPECT_EQ(ety.data.buf, buf); raft_entry_t* kept = raft_get_entry_from_idx(r, 1); - CuAssertTrue(tc, NULL != kept->data.buf); + EXPECT_NE(nullptr, kept->data.buf); /* Data buf is the one set by log_offer. */ - CuAssertTrue(tc, kept->data.buf == tc); + EXPECT_EQ(kept->data.buf, r); } #if 0 @@ -331,27 +327,27 @@ T_estRaft_server_append_entry_not_sucessful_if_entry_with_id_already_appended( ety.term = 1; r = raft_new(); - CuAssertTrue(tc, 1 == raft_get_current_idx(r)); + EXPECT_EQ(1, raft_get_current_idx(r)); raft_append_entry(r, &ety); raft_append_entry(r, &ety); - CuAssertTrue(tc, 2 == raft_get_current_idx(r)); + EXPECT_EQ(2, raft_get_current_idx(r)); /* different ID so we can be successful */ ety.id = 2; raft_append_entry(r, &ety); - CuAssertTrue(tc, 3 == raft_get_current_idx(r)); + EXPECT_EQ(3, raft_get_current_idx(r)); } #endif -void TestRaft_server_entry_is_retrieveable_using_idx(CuTest* tc) +TEST(TestServer, entry_is_retrieveable_using_idx) { - raft_entry_t e1 = {}; - raft_entry_t e2 = {}; + raft_entry_t e1 = {0}; + raft_entry_t e2 = {0}; raft_entry_t *ety_appended; char *str = "aaa"; char *str2 = "bbb"; - void *r = raft_new(); + raft_server_t *r = raft_new(); e1.term = 1; e1.id = 1; @@ -366,24 +362,25 @@ void TestRaft_server_entry_is_retrieveable_using_idx(CuTest* tc) e2.data.len = 3; raft_append_entry(r, &e2); - CuAssertTrue(tc, NULL != (ety_appended = raft_get_entry_from_idx(r, 2))); - CuAssertTrue(tc, !strncmp(ety_appended->data.buf, str2, 3)); + ety_appended = raft_get_entry_from_idx(r, 2); + EXPECT_NE(nullptr, ety_appended); + EXPECT_EQ(0, strncmp((const char*)ety_appended->data.buf, str2, 3)); } -void TestRaft_server_wont_apply_entry_if_we_dont_have_entry_to_apply(CuTest* tc) +TEST(TestServer, wont_apply_entry_if_we_dont_have_entry_to_apply) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_commit_idx(r, 0); raft_set_last_applied_idx(r, 0); raft_apply_entry(r); - CuAssertTrue(tc, 0 == raft_get_last_applied_idx(r)); - CuAssertTrue(tc, 0 == raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); } -void TestRaft_server_wont_apply_entry_if_there_isnt_a_majority(CuTest* tc) +TEST(TestServer, wont_apply_entry_if_there_isnt_a_majority) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); @@ -391,11 +388,11 @@ void TestRaft_server_wont_apply_entry_if_there_isnt_a_majority(CuTest* tc) raft_set_last_applied_idx(r, 0); raft_apply_entry(r); - CuAssertTrue(tc, 0 == raft_get_last_applied_idx(r)); - CuAssertTrue(tc, 0 == raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); char *str = "aaa"; - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = str; @@ -403,21 +400,19 @@ void TestRaft_server_wont_apply_entry_if_there_isnt_a_majority(CuTest* tc) raft_append_entry(r, &ety); raft_apply_entry(r); /* Not allowed to be applied because we haven't confirmed a majority yet */ - CuAssertTrue(tc, 0 == raft_get_last_applied_idx(r)); - CuAssertTrue(tc, 0 == raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); } /* If commitidx > lastApplied: increment lastApplied, apply log[lastApplied] - * to state machine (§5.3) */ -void TestRaft_server_increment_lastApplied_when_lastApplied_lt_commitidx( - CuTest* tc) + * to state machine (§5.3) */ +TEST(TestServer, increment_lastApplied_when_lastApplied_lt_commitidx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .applylog = __raft_applylog, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.applylog = __raft_applylog; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); /* must be follower */ @@ -426,7 +421,7 @@ void TestRaft_server_increment_lastApplied_when_lastApplied_lt_commitidx( raft_set_last_applied_idx(r, 0); /* need at least one entry */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaa"; @@ -437,20 +432,19 @@ void TestRaft_server_increment_lastApplied_when_lastApplied_lt_commitidx( /* let time lapse */ raft_periodic(r, 1); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); } -void TestRaft_server_apply_entry_increments_last_applied_idx(CuTest* tc) +TEST(TestServer, apply_entry_increments_last_applied_idx) { - raft_cbs_t funcs = { - .applylog = __raft_applylog, - }; + raft_cbs_t funcs = {0}; + funcs.applylog = __raft_applylog; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_set_last_applied_idx(r, 0); - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaa"; @@ -458,32 +452,31 @@ void TestRaft_server_apply_entry_increments_last_applied_idx(CuTest* tc) raft_append_entry(r, &ety); raft_set_commit_idx(r, 1); raft_apply_entry(r); - CuAssertTrue(tc, 1 == raft_get_last_applied_idx(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); } -void TestRaft_server_periodic_elapses_election_timeout(CuTest * tc) +TEST(TestServer, periodic_elapses_election_timeout) { - void *r = raft_new(); + raft_server_t *r = raft_new(); /* we don't want to set the timeout to zero */ raft_set_election_timeout(r, 1000); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); raft_periodic(r, 0); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); raft_periodic(r, 100); - CuAssertTrue(tc, 100 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(100, raft_get_timeout_elapsed(r)); } -void TestRaft_server_election_timeout_does_not_promote_us_to_leader_if_there_is_are_more_than_1_nodes(CuTest * tc) +TEST(TestServer, election_timeout_does_not_promote_us_to_leader_if_there_is_are_more_than_1_nodes) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -493,25 +486,25 @@ void TestRaft_server_election_timeout_does_not_promote_us_to_leader_if_there_is_ /* clock over (ie. 1000 + 1), causing new election */ raft_periodic(r, 1001); - CuAssertTrue(tc, 0 == raft_is_leader(r)); + EXPECT_EQ(0, raft_is_leader(r)); } -void TestRaft_server_election_timeout_does_not_promote_us_to_leader_if_we_are_not_voting_node(CuTest * tc) +TEST(TestServer, election_timeout_does_not_promote_us_to_leader_if_we_are_not_voting_node) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_non_voting_node(r, NULL, 1, 1); raft_set_election_timeout(r, 1000); /* clock over (ie. 1000 + 1), causing new election */ raft_periodic(r, 1001); - CuAssertTrue(tc, 0 == raft_is_leader(r)); - CuAssertTrue(tc, 0 == raft_get_current_term(r)); + EXPECT_EQ(0, raft_is_leader(r)); + EXPECT_EQ(0, raft_get_current_term(r)); } -void TestRaft_server_election_timeout_does_not_start_election_if_there_are_no_voting_nodes(CuTest * tc) +TEST(TestServer, election_timeout_does_not_start_election_if_there_are_no_voting_nodes) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_non_voting_node(r, NULL, 1, 1); raft_add_non_voting_node(r, NULL, 2, 0); raft_set_election_timeout(r, 1000); @@ -519,28 +512,27 @@ void TestRaft_server_election_timeout_does_not_start_election_if_there_are_no_vo /* clock over (ie. 1000 + 1), causing new election */ raft_periodic(r, 1001); - CuAssertTrue(tc, 0 == raft_get_current_term(r)); + EXPECT_EQ(0, raft_get_current_term(r)); } -void TestRaft_server_election_timeout_does_promote_us_to_leader_if_there_is_only_1_node(CuTest * tc) +TEST(TestServer, election_timeout_does_promote_us_to_leader_if_there_is_only_1_node) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_set_election_timeout(r, 1000); /* clock over (ie. 1000 + 1), causing new election */ raft_periodic(r, 1001); - CuAssertTrue(tc, 1 == raft_is_leader(r)); + EXPECT_EQ(1, raft_is_leader(r)); } -void TestRaft_server_election_timeout_does_promote_us_to_leader_if_there_is_only_1_voting_node(CuTest * tc) +TEST(TestServer, election_timeout_does_promote_us_to_leader_if_there_is_only_1_voting_node) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -550,19 +542,19 @@ void TestRaft_server_election_timeout_does_promote_us_to_leader_if_there_is_only /* clock over (ie. 1000 + 1), causing new election */ raft_periodic(r, 1001); - CuAssertTrue(tc, 1 == raft_is_leader(r)); + EXPECT_EQ(1, raft_is_leader(r)); } -void TestRaft_server_recv_entry_auto_commits_if_we_are_the_only_node(CuTest * tc) +TEST(TestServer, recv_entry_auto_commits_if_we_are_the_only_node) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_set_election_timeout(r, 1000); raft_become_leader(r); - CuAssertTrue(tc, 0 == raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); /* entry message */ - msg_entry_t ety = {}; + msg_entry_t ety = {0}; ety.id = 1; ety.data.buf = "entry"; ety.data.len = strlen("entry"); @@ -570,20 +562,20 @@ void TestRaft_server_recv_entry_auto_commits_if_we_are_the_only_node(CuTest * tc /* receive entry */ msg_entry_response_t cr; raft_recv_entry(r, &ety, &cr); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); - CuAssertTrue(tc, 1 == raft_get_commit_idx(r)); + EXPECT_EQ(1, raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_commit_idx(r)); } -void TestRaft_server_recv_entry_fails_if_there_is_already_a_voting_change(CuTest * tc) +TEST(TestServer, recv_entry_fails_if_there_is_already_a_voting_change) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_set_election_timeout(r, 1000); raft_become_leader(r); - CuAssertTrue(tc, 0 == raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); /* entry message */ - msg_entry_t ety = {}; + msg_entry_t ety = {0}; ety.type = RAFT_LOGTYPE_ADD_NODE; ety.id = 1; ety.data.buf = "entry"; @@ -591,158 +583,144 @@ void TestRaft_server_recv_entry_fails_if_there_is_already_a_voting_change(CuTest /* receive entry */ msg_entry_response_t cr; - CuAssertTrue(tc, 0 == raft_recv_entry(r, &ety, &cr)); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_EQ(0, raft_recv_entry(r, &ety, &cr)); + EXPECT_EQ(1, raft_get_log_count(r)); ety.id = 2; - CuAssertTrue(tc, RAFT_ERR_ONE_VOTING_CHANGE_ONLY == raft_recv_entry(r, &ety, &cr)); - CuAssertTrue(tc, 1 == raft_get_commit_idx(r)); + EXPECT_EQ(RAFT_ERR_ONE_VOTING_CHANGE_ONLY, raft_recv_entry(r, &ety, &cr)); + EXPECT_EQ(1, raft_get_commit_idx(r)); } -void TestRaft_server_cfg_sets_num_nodes(CuTest * tc) +TEST(TestServer, cfg_sets_num_nodes) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); - CuAssertTrue(tc, 2 == raft_get_num_nodes(r)); + EXPECT_EQ(2, raft_get_num_nodes(r)); } -void TestRaft_server_cant_get_node_we_dont_have(CuTest * tc) +TEST(TestServer, cant_get_node_we_dont_have) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); - CuAssertTrue(tc, NULL == raft_get_node(r, 0)); - CuAssertTrue(tc, NULL != raft_get_node(r, 1)); - CuAssertTrue(tc, NULL != raft_get_node(r, 2)); - CuAssertTrue(tc, NULL == raft_get_node(r, 3)); + EXPECT_EQ(nullptr, raft_get_node(r, 0)); + EXPECT_NE(nullptr, raft_get_node(r, 1)); + EXPECT_NE(nullptr, raft_get_node(r, 2)); + EXPECT_EQ(nullptr, raft_get_node(r, 3)); } /* If term > currentTerm, set currentTerm to term (step down if candidate or * leader) */ -void TestRaft_votes_are_majority_is_true( - CuTest * tc - ) +TEST(TestServer, votes_are_majority_is_true) { /* 1 of 3 = lose */ - CuAssertTrue(tc, 0 == raft_votes_is_majority(3, 1)); + EXPECT_EQ(0, raft_votes_is_majority(3, 1)); /* 2 of 3 = win */ - CuAssertTrue(tc, 1 == raft_votes_is_majority(3, 2)); + EXPECT_EQ(1, raft_votes_is_majority(3, 2)); /* 2 of 5 = lose */ - CuAssertTrue(tc, 0 == raft_votes_is_majority(5, 2)); + EXPECT_EQ(0, raft_votes_is_majority(5, 2)); /* 3 of 5 = win */ - CuAssertTrue(tc, 1 == raft_votes_is_majority(5, 3)); + EXPECT_EQ(1, raft_votes_is_majority(5, 3)); /* 2 of 1?? This is an error */ - CuAssertTrue(tc, 0 == raft_votes_is_majority(1, 2)); + EXPECT_EQ(0, raft_votes_is_majority(1, 2)); } -void TestRaft_server_recv_requestvote_response_dont_increase_votes_for_me_when_not_granted( - CuTest * tc - ) +TEST(TestServer, recv_requestvote_response_dont_increase_votes_for_me_when_not_granted) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_current_term(r, 1); - CuAssertTrue(tc, 0 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(0, raft_get_nvotes_for_me(r)); msg_requestvote_response_t rvr; memset(&rvr, 0, sizeof(msg_requestvote_response_t)); rvr.term = 1; rvr.vote_granted = 0; int e = raft_recv_requestvote_response(r, raft_get_node(r, 2), &rvr); - CuAssertIntEquals(tc, 0, e); - CuAssertTrue(tc, 0 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(0, e); + EXPECT_EQ(0, raft_get_nvotes_for_me(r)); } -void TestRaft_server_recv_requestvote_response_dont_increase_votes_for_me_when_term_is_not_equal( - CuTest * tc - ) +TEST(TestServer, recv_requestvote_response_dont_increase_votes_for_me_when_term_is_not_equal) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_current_term(r, 3); - CuAssertTrue(tc, 0 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(0, raft_get_nvotes_for_me(r)); msg_requestvote_response_t rvr; memset(&rvr, 0, sizeof(msg_requestvote_response_t)); rvr.term = 2; rvr.vote_granted = 1; raft_recv_requestvote_response(r, raft_get_node(r, 2), &rvr); - CuAssertTrue(tc, 0 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(0, raft_get_nvotes_for_me(r)); } -void TestRaft_server_recv_requestvote_response_increase_votes_for_me( - CuTest * tc - ) +TEST(TestServer, recv_requestvote_response_increase_votes_for_me) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_current_term(r, 1); - CuAssertTrue(tc, 0 == raft_get_nvotes_for_me(r)); - CuAssertIntEquals(tc, 1, raft_get_current_term(r)); + EXPECT_EQ(0, raft_get_nvotes_for_me(r)); + EXPECT_EQ(1, raft_get_current_term(r)); raft_become_candidate(r); - CuAssertIntEquals(tc, 2, raft_get_current_term(r)); - CuAssertTrue(tc, 1 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(2, raft_get_current_term(r)); + EXPECT_EQ(1, raft_get_nvotes_for_me(r)); msg_requestvote_response_t rvr; memset(&rvr, 0, sizeof(msg_requestvote_response_t)); rvr.term = 2; rvr.vote_granted = 1; int e = raft_recv_requestvote_response(r, raft_get_node(r, 2), &rvr); - CuAssertIntEquals(tc, 0, e); - CuAssertTrue(tc, 2 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(0, e); + EXPECT_EQ(2, raft_get_nvotes_for_me(r)); } -void TestRaft_server_recv_requestvote_response_must_be_candidate_to_receive( - CuTest * tc - ) +TEST(TestServer, recv_requestvote_response_must_be_candidate_to_receive) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_current_term(r, 1); - CuAssertTrue(tc, 0 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(0, raft_get_nvotes_for_me(r)); raft_become_leader(r); @@ -751,20 +729,17 @@ void TestRaft_server_recv_requestvote_response_must_be_candidate_to_receive( rvr.term = 1; rvr.vote_granted = 1; raft_recv_requestvote_response(r, raft_get_node(r, 2), &rvr); - CuAssertTrue(tc, 0 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(0, raft_get_nvotes_for_me(r)); } -/* Reply false if term < currentTerm (§5.1) */ -void TestRaft_server_recv_requestvote_reply_false_if_term_less_than_current_term( - CuTest * tc - ) +/* Reply false if term < currentTerm (§5.1) */ +TEST(TestServer, recv_requestvote_reply_false_if_term_less_than_current_term) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_requestvote_response_t rvr; @@ -778,21 +753,18 @@ void TestRaft_server_recv_requestvote_reply_false_if_term_less_than_current_term memset(&rv, 0, sizeof(msg_requestvote_t)); rv.term = 1; int e = raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertIntEquals(tc, 0, e); - CuAssertIntEquals(tc, 0, rvr.vote_granted); + EXPECT_EQ(0, e); + EXPECT_EQ(0, rvr.vote_granted); } -void TestRaft_leader_recv_requestvote_does_not_step_down( - CuTest * tc - ) +TEST(TestServer, leader_recv_requestvote_does_not_step_down) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_requestvote_response_t rvr; @@ -802,30 +774,27 @@ void TestRaft_leader_recv_requestvote_does_not_step_down( raft_set_current_term(r, 1); raft_vote(r, raft_get_node(r, 1)); raft_become_leader(r); - CuAssertIntEquals(tc, 1, raft_is_leader(r)); + EXPECT_EQ(1, raft_is_leader(r)); /* term is less than current term */ msg_requestvote_t rv; memset(&rv, 0, sizeof(msg_requestvote_t)); rv.term = 1; raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertIntEquals(tc, 1, raft_get_current_leader(r)); + EXPECT_EQ(1, raft_get_current_leader(r)); } -/* Reply true if term >= currentTerm (§5.1) */ -void TestRaft_server_recv_requestvote_reply_true_if_term_greater_than_or_equal_to_current_term( - CuTest * tc - ) +/* Reply true if term >= currentTerm (§5.1) */ +TEST(TestServer, recv_requestvote_reply_true_if_term_greater_than_or_equal_to_current_term) { msg_requestvote_t rv; msg_requestvote_response_t rvr; - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -838,22 +807,19 @@ void TestRaft_server_recv_requestvote_reply_true_if_term_greater_than_or_equal_t rv.last_log_idx = 1; raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertTrue(tc, 1 == rvr.vote_granted); + EXPECT_EQ(1, rvr.vote_granted); } -void TestRaft_server_recv_requestvote_reset_timeout( - CuTest * tc - ) +TEST(TestServer, recv_requestvote_reset_timeout) { msg_requestvote_t rv; msg_requestvote_response_t rvr; - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -867,28 +833,25 @@ void TestRaft_server_recv_requestvote_reset_timeout( rv.term = 2; rv.last_log_idx = 1; raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertTrue(tc, 1 == rvr.vote_granted); - CuAssertIntEquals(tc, 0, raft_get_timeout_elapsed(r)); + EXPECT_EQ(1, rvr.vote_granted); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); } -void TestRaft_server_recv_requestvote_candidate_step_down_if_term_is_higher_than_current_term( - CuTest * tc - ) +TEST(TestServer, recv_requestvote_candidate_step_down_if_term_is_higher_than_current_term) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_become_candidate(r); raft_set_current_term(r, 1); - CuAssertIntEquals(tc, 1, raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); /* current term is less than term */ msg_requestvote_t rv; @@ -898,29 +861,26 @@ void TestRaft_server_recv_requestvote_candidate_step_down_if_term_is_higher_than rv.last_log_idx = 1; msg_requestvote_response_t rvr; raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertIntEquals(tc, 1, raft_is_follower(r)); - CuAssertIntEquals(tc, 2, raft_get_current_term(r)); - CuAssertIntEquals(tc, 2, raft_get_voted_for(r)); + EXPECT_EQ(1, raft_is_follower(r)); + EXPECT_EQ(2, raft_get_current_term(r)); + EXPECT_EQ(2, raft_get_voted_for(r)); } -void TestRaft_server_recv_requestvote_depends_on_candidate_id( - CuTest * tc - ) +TEST(TestServer, recv_requestvote_depends_on_candidate_id) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_become_candidate(r); raft_set_current_term(r, 1); - CuAssertIntEquals(tc, 1, raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); /* current term is less than term */ msg_requestvote_t rv; @@ -930,23 +890,20 @@ void TestRaft_server_recv_requestvote_depends_on_candidate_id( rv.last_log_idx = 1; msg_requestvote_response_t rvr; raft_recv_requestvote(r, NULL, &rv, &rvr); - CuAssertIntEquals(tc, 1, raft_is_follower(r)); - CuAssertIntEquals(tc, 2, raft_get_current_term(r)); - CuAssertIntEquals(tc, 3, raft_get_voted_for(r)); + EXPECT_EQ(1, raft_is_follower(r)); + EXPECT_EQ(2, raft_get_current_term(r)); + EXPECT_EQ(3, raft_get_voted_for(r)); } /* If votedFor is null or candidateId, and candidate's log is at - * least as up-to-date as local log, grant vote (§5.2, §5.4) */ -void TestRaft_server_recv_requestvote_dont_grant_vote_if_we_didnt_vote_for_this_candidate( - CuTest * tc - ) + * least as up-to-date as local log, grant vote (§5.2, §5.4) */ +TEST(TestServer, recv_requestvote_dont_grant_vote_if_we_didnt_vote_for_this_candidate) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 0, 0); @@ -957,61 +914,58 @@ void TestRaft_server_recv_requestvote_dont_grant_vote_if_we_didnt_vote_for_this_ /* vote for self */ raft_vote_for_nodeid(r, 1); - msg_requestvote_t rv = {}; + msg_requestvote_t rv = {0}; rv.term = 1; rv.candidate_id = 1; rv.last_log_idx = 1; rv.last_log_term = 1; msg_requestvote_response_t rvr; raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertTrue(tc, 0 == rvr.vote_granted); + EXPECT_EQ(0, rvr.vote_granted); /* vote for ID 0 */ raft_vote_for_nodeid(r, 0); raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertTrue(tc, 0 == rvr.vote_granted); + EXPECT_EQ(0, rvr.vote_granted); } -void TestRaft_follower_becomes_follower_is_follower(CuTest * tc) +TEST(TestFollower, becomes_follower_is_follower) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_become_follower(r); - CuAssertTrue(tc, raft_is_follower(r)); + EXPECT_TRUE(raft_is_follower(r)); } -void TestRaft_follower_becomes_follower_does_not_clear_voted_for(CuTest * tc) +TEST(TestFollower, becomes_follower_does_not_clear_voted_for) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_vote(r, raft_get_node(r, 1)); - CuAssertIntEquals(tc, 1, raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); raft_become_follower(r); - CuAssertIntEquals(tc, 1, raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); } /* 5.1 */ -void TestRaft_follower_recv_appendentries_reply_false_if_term_less_than_currentterm( - CuTest * tc) +TEST(TestFollower, recv_appendentries_reply_false_if_term_less_than_currentterm) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); /* no leader known at this point */ - CuAssertTrue(tc, -1 == raft_get_current_leader(r)); + EXPECT_EQ(-1, raft_get_current_leader(r)); /* term is low */ msg_appendentries_t ae; @@ -1023,38 +977,35 @@ void TestRaft_follower_recv_appendentries_reply_false_if_term_less_than_currentt msg_appendentries_response_t aer; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 0 == aer.success); + EXPECT_FALSE(aer.success); /* rejected appendentries doesn't change the current leader. */ - CuAssertTrue(tc, -1 == raft_get_current_leader(r)); + EXPECT_EQ(-1, raft_get_current_leader(r)); } -void TestRaft_follower_recv_appendentries_does_not_need_node(CuTest * tc) +TEST(TestFollower, recv_appendentries_does_not_need_node) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); - msg_appendentries_t ae = {}; + msg_appendentries_t ae = {0}; ae.term = 1; msg_appendentries_response_t aer; raft_recv_appendentries(r, NULL, &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); + EXPECT_TRUE(aer.success); } /* TODO: check if test case is needed */ -void TestRaft_follower_recv_appendentries_updates_currentterm_if_term_gt_currentterm( - CuTest * tc) +TEST(TestFollower, recv_appendentries_updates_currentterm_if_term_gt_currentterm) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -1065,7 +1016,7 @@ void TestRaft_follower_recv_appendentries_updates_currentterm_if_term_gt_current /* older currentterm */ raft_set_current_term(r, 1); - CuAssertTrue(tc, -1 == raft_get_current_leader(r)); + EXPECT_EQ(-1, raft_get_current_leader(r)); /* newer term for appendentry */ memset(&ae, 0, sizeof(msg_appendentries_t)); @@ -1075,22 +1026,20 @@ void TestRaft_follower_recv_appendentries_updates_currentterm_if_term_gt_current /* appendentry has newer term, so we change our currentterm */ raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertTrue(tc, 2 == aer.term); + EXPECT_TRUE(aer.success); + EXPECT_EQ(2, aer.term); /* term has been updated */ - CuAssertTrue(tc, 2 == raft_get_current_term(r)); + EXPECT_EQ(2, raft_get_current_term(r)); /* and leader has been updated */ - CuAssertIntEquals(tc, 2, raft_get_current_leader(r)); + EXPECT_EQ(2, raft_get_current_leader(r)); } -void TestRaft_follower_recv_appendentries_does_not_log_if_no_entries_are_specified( - CuTest * tc) +TEST(TestFollower, recv_appendentries_does_not_log_if_no_entries_are_specified) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -1102,7 +1051,7 @@ void TestRaft_follower_recv_appendentries_does_not_log_if_no_entries_are_specifi raft_set_state(r, RAFT_STATE_FOLLOWER); /* log size s */ - CuAssertTrue(tc, 0 == raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* receive an appendentry with commit */ memset(&ae, 0, sizeof(msg_appendentries_t)); @@ -1113,20 +1062,19 @@ void TestRaft_follower_recv_appendentries_does_not_log_if_no_entries_are_specifi ae.n_entries = 0; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 0 == raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); } -void TestRaft_follower_recv_appendentries_increases_log(CuTest * tc) +TEST(TestFollower, recv_appendentries_increases_log) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; - msg_entry_t ety = {}; + msg_entry_t ety = {0}; msg_appendentries_response_t aer; char *str = "aaa"; @@ -1136,7 +1084,7 @@ void TestRaft_follower_recv_appendentries_increases_log(CuTest * tc) raft_set_state(r, RAFT_STATE_FOLLOWER); /* log size s */ - CuAssertTrue(tc, 0 == raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* receive an appendentry with commit */ memset(&ae, 0, sizeof(msg_appendentries_t)); @@ -1156,24 +1104,22 @@ void TestRaft_follower_recv_appendentries_increases_log(CuTest * tc) ae.n_entries = 1; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_TRUE(aer.success); + EXPECT_EQ(1, raft_get_log_count(r)); raft_entry_t* log = raft_get_entry_from_idx(r, 1); - CuAssertTrue(tc, 2 == log->term); + EXPECT_EQ(2, log->term); } /* 5.3 */ -void TestRaft_follower_recv_appendentries_reply_false_if_doesnt_have_log_at_prev_log_idx_which_matches_prev_log_term( - CuTest * tc) +TEST(TestFollower, recv_appendentries_reply_false_if_doesnt_have_log_at_prev_log_idx_which_matches_prev_log_term) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); - msg_entry_t ety = {}; + msg_entry_t ety = {0}; char *str = "aaa"; msg_appendentries_t ae; @@ -1204,15 +1150,12 @@ void TestRaft_follower_recv_appendentries_reply_false_if_doesnt_have_log_at_prev raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); /* reply is false */ - CuAssertTrue(tc, 0 == aer.success); + EXPECT_FALSE(aer.success); } -static raft_entry_t* __create_mock_entries_for_conflict_tests( - CuTest * tc, - raft_server_t* r, - char** strs) +static raft_entry_t* __create_mock_entries_for_conflict_tests(raft_server_t* r, char** strs) { - raft_entry_t ety = {}; + raft_entry_t ety = {0}; raft_entry_t *ety_appended; /* increase log size */ @@ -1222,7 +1165,7 @@ static raft_entry_t* __create_mock_entries_for_conflict_tests( ety.id = 1; ety.term = 1; raft_append_entry(r, &ety); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_log_count(r)); /* this log will be overwritten by a later appendentries */ char *str2 = strs[1]; @@ -1231,9 +1174,9 @@ static raft_entry_t* __create_mock_entries_for_conflict_tests( ety.id = 2; ety.term = 1; raft_append_entry(r, &ety); - CuAssertTrue(tc, 2 == raft_get_log_count(r)); - CuAssertTrue(tc, NULL != (ety_appended = raft_get_entry_from_idx(r, 2))); - CuAssertTrue(tc, !strncmp(ety_appended->data.buf, str2, 3)); + EXPECT_EQ(2, raft_get_log_count(r)); + EXPECT_NE(nullptr, (ety_appended = raft_get_entry_from_idx(r, 2))); + EXPECT_EQ(0, strncmp((const char*)ety_appended->data.buf, str2, 3)); /* this log will be overwritten by a later appendentries */ char *str3 = strs[2]; @@ -1242,22 +1185,20 @@ static raft_entry_t* __create_mock_entries_for_conflict_tests( ety.id = 3; ety.term = 1; raft_append_entry(r, &ety); - CuAssertTrue(tc, 3 == raft_get_log_count(r)); - CuAssertTrue(tc, NULL != (ety_appended = raft_get_entry_from_idx(r, 3))); - CuAssertTrue(tc, !strncmp(ety_appended->data.buf, str3, 3)); + EXPECT_EQ(3, raft_get_log_count(r)); + EXPECT_NE(nullptr, (ety_appended = raft_get_entry_from_idx(r, 3))); + EXPECT_EQ(0, strncmp((const char*)ety_appended->data.buf, str3, 3)); return ety_appended; } /* 5.3 */ -void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_entries_via_prev_log_idx( - CuTest * tc) +TEST(TestFollower, recv_appendentries_delete_entries_if_conflict_with_new_entries_via_prev_log_idx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -1269,10 +1210,10 @@ void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_en raft_set_current_term(r, 1); char* strs[] = {"111", "222", "333"}; - raft_entry_t *ety_appended = __create_mock_entries_for_conflict_tests(tc, r, strs); + raft_entry_t *ety_appended = __create_mock_entries_for_conflict_tests(r, strs); /* pass a appendentry that is newer */ - msg_entry_t mety = {}; + msg_entry_t mety = {0}; memset(&ae, 0, sizeof(msg_appendentries_t)); ae.term = 2; @@ -1290,24 +1231,22 @@ void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_en /* str4 has overwritten the last 2 entries */ raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertTrue(tc, 2 == raft_get_log_count(r)); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(2, raft_get_log_count(r)); /* str1 is still there */ - CuAssertTrue(tc, NULL != (ety_appended = raft_get_entry_from_idx(r, 1))); - CuAssertTrue(tc, !strncmp(ety_appended->data.buf, strs[0], 3)); + EXPECT_NE(nullptr, (ety_appended = raft_get_entry_from_idx(r, 1))); + EXPECT_EQ(0, strncmp((const char*)ety_appended->data.buf, strs[0], 3)); /* str4 has overwritten the last 2 entries */ - CuAssertTrue(tc, NULL != (ety_appended = raft_get_entry_from_idx(r, 2))); - CuAssertTrue(tc, !strncmp(ety_appended->data.buf, str4, 3)); + EXPECT_NE(nullptr, (ety_appended = raft_get_entry_from_idx(r, 2))); + EXPECT_EQ(0, strncmp((const char*)ety_appended->data.buf, str4, 3)); } -void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_entries_via_prev_log_idx_at_idx_0( - CuTest * tc) +TEST(TestFollower, recv_appendentries_delete_entries_if_conflict_with_new_entries_via_prev_log_idx_at_idx_0) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -1319,10 +1258,10 @@ void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_en raft_set_current_term(r, 1); char* strs[] = {"111", "222", "333"}; - raft_entry_t *ety_appended = __create_mock_entries_for_conflict_tests(tc, r, strs); + raft_entry_t *ety_appended = __create_mock_entries_for_conflict_tests(r, strs); /* pass a appendentry that is newer */ - msg_entry_t mety = {}; + msg_entry_t mety = {0}; memset(&ae, 0, sizeof(msg_appendentries_t)); ae.term = 2; @@ -1339,21 +1278,19 @@ void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_en ae.n_entries = 1; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(1, raft_get_log_count(r)); /* str1 is gone */ - CuAssertTrue(tc, NULL != (ety_appended = raft_get_entry_from_idx(r, 1))); - CuAssertTrue(tc, !strncmp(ety_appended->data.buf, str4, 3)); + EXPECT_NE(nullptr, (ety_appended = raft_get_entry_from_idx(r, 1))); + EXPECT_EQ(0, strncmp((const char*)ety_appended->data.buf, str4, 3)); } -void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_entries_greater_than_prev_log_idx( - CuTest * tc) +TEST(TestFollower, recv_appendentries_delete_entries_if_conflict_with_new_entries_greater_than_prev_log_idx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -1367,8 +1304,8 @@ void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_en char* strs[] = {"111", "222", "333"}; raft_entry_t *ety_appended; - __create_mock_entries_for_conflict_tests(tc, r, strs); - CuAssertIntEquals(tc, 3, raft_get_log_count(r)); + __create_mock_entries_for_conflict_tests(r, strs); + EXPECT_EQ(3, raft_get_log_count(r)); memset(&ae, 0, sizeof(msg_appendentries_t)); ae.term = 2; @@ -1381,22 +1318,20 @@ void TestRaft_follower_recv_appendentries_delete_entries_if_conflict_with_new_en ae.n_entries = 1; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertIntEquals(tc, 2, raft_get_log_count(r)); - CuAssertTrue(tc, NULL != (ety_appended = raft_get_entry_from_idx(r, 1))); - CuAssertTrue(tc, !strncmp(ety_appended->data.buf, strs[0], 3)); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(2, raft_get_log_count(r)); + EXPECT_NE(nullptr, (ety_appended = raft_get_entry_from_idx(r, 1))); + EXPECT_EQ(0, strncmp((const char*)ety_appended->data.buf, strs[0], 3)); } // TODO: add TestRaft_follower_recv_appendentries_delete_entries_if_term_is_different -void TestRaft_follower_recv_appendentries_add_new_entries_not_already_in_log( - CuTest * tc) +TEST(TestFollower, recv_appendentries_add_new_entries_not_already_in_log) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -1419,18 +1354,16 @@ void TestRaft_follower_recv_appendentries_add_new_entries_not_already_in_log( ae.n_entries = 2; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertTrue(tc, 2 == raft_get_log_count(r)); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(2, raft_get_log_count(r)); } -void TestRaft_follower_recv_appendentries_does_not_add_dupe_entries_already_in_log( - CuTest * tc) +TEST(TestFollower, recv_appendentries_does_not_add_dupe_entries_already_in_log) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -1455,16 +1388,16 @@ void TestRaft_follower_recv_appendentries_does_not_add_dupe_entries_already_in_l memset(&aer, 0, sizeof(aer)); raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); /* still successful even when no raft_append_entry() happened! */ - CuAssertTrue(tc, 1 == aer.success); - CuAssertIntEquals(tc, 1, raft_get_log_count(r)); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(1, raft_get_log_count(r)); /* lets get the server to append 2 now! */ e[1].id = 2; ae.n_entries = 2; memset(&aer, 0, sizeof(aer)); raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertIntEquals(tc, 2, raft_get_log_count(r)); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(2, raft_get_log_count(r)); } typedef enum { @@ -1484,7 +1417,7 @@ static int __raft_log_offer_error( raft_entry_t *entry, int entry_idx) { - __raft_error_t *error = user_data; + __raft_error_t *error = (__raft_error_t*)user_data; if (__RAFT_LOG_OFFER_ERR == error->type && entry_idx == error->idx) return RAFT_ERR_NOMEM; @@ -1497,23 +1430,22 @@ static int __raft_log_pop_error( raft_entry_t *entry, int entry_idx) { - __raft_error_t *error = user_data; + __raft_error_t *error = (__raft_error_t*)user_data; if (__RAFT_LOG_POP_ERR == error->type && entry_idx == error->idx) return RAFT_ERR_NOMEM; return 0; } -void TestRaft_follower_recv_appendentries_partial_failures( - CuTest * tc) +TEST(TestFollower, recv_appendentries_partial_failures) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .log_offer = __raft_log_offer_error, - .log_pop = __raft_log_pop_error - }; + raft_cbs_t funcs = { 0 }; - void *r = raft_new(); + funcs.persist_term = __raft_persist_term; + funcs.log_offer = __raft_log_offer_error; + funcs.log_pop = __raft_log_pop_error; + + raft_server_t *r = raft_new(); __raft_error_t error = {}; raft_set_callbacks(r, &funcs, &error); @@ -1533,7 +1465,7 @@ void TestRaft_follower_recv_appendentries_partial_failures( ety.id = 2; ety.term = 1; raft_append_entry(r, &ety); - CuAssertIntEquals(tc, 2, raft_get_current_idx(r)); + EXPECT_EQ(2, raft_get_current_idx(r)); msg_appendentries_t ae; msg_appendentries_response_t aer; @@ -1557,47 +1489,45 @@ void TestRaft_follower_recv_appendentries_partial_failures( error.idx = 2; memset(&aer, 0, sizeof(aer)); int err = raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertIntEquals(tc, RAFT_ERR_NOMEM, err); - CuAssertIntEquals(tc, 1, aer.success); - CuAssertIntEquals(tc, 1, aer.current_idx); - CuAssertIntEquals(tc, 2, raft_get_current_idx(r)); + EXPECT_EQ(RAFT_ERR_NOMEM, err); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(1, aer.current_idx); + EXPECT_EQ(2, raft_get_current_idx(r)); raft_entry_t *tmp = raft_get_entry_from_idx(r, 2); - CuAssertTrue(tc, NULL != tmp); - CuAssertIntEquals(tc, 1, tmp->term); + EXPECT_NE(nullptr, tmp); + EXPECT_EQ(1, tmp->term); /* Ask log_offer to fail at entry 3. */ error.type = __RAFT_LOG_OFFER_ERR; error.idx = 3; memset(&aer, 0, sizeof(aer)); err = raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertIntEquals(tc, RAFT_ERR_NOMEM, err); - CuAssertIntEquals(tc, 1, aer.success); - CuAssertIntEquals(tc, 2, aer.current_idx); - CuAssertIntEquals(tc, 2, raft_get_current_idx(r)); + EXPECT_EQ(RAFT_ERR_NOMEM, err); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(2, aer.current_idx); + EXPECT_EQ(2, raft_get_current_idx(r)); tmp = raft_get_entry_from_idx(r, 2); - CuAssertTrue(tc, NULL != tmp); - CuAssertIntEquals(tc, 2, tmp->term); + EXPECT_NE(nullptr, tmp); + EXPECT_EQ(2, tmp->term); /* No more errors. */ memset(&error, 0, sizeof(error)); memset(&aer, 0, sizeof(aer)); err = raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertIntEquals(tc, 0, err); - CuAssertIntEquals(tc, 1, aer.success); - CuAssertIntEquals(tc, 3, aer.current_idx); - CuAssertIntEquals(tc, 3, raft_get_current_idx(r)); + EXPECT_EQ(0, err); + EXPECT_EQ(1, aer.success); + EXPECT_EQ(3, aer.current_idx); + EXPECT_EQ(3, raft_get_current_idx(r)); } /* If leaderCommit > commitidx, set commitidx = * min(leaderCommit, last log idx) */ -void TestRaft_follower_recv_appendentries_set_commitidx_to_prevLogIdx( - CuTest * tc) +TEST(TestFollower, recv_appendentries_set_commitidx_to_prevLogIdx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -1634,19 +1564,17 @@ void TestRaft_follower_recv_appendentries_set_commitidx_to_prevLogIdx( /* receipt of appendentries changes commit idx */ raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); + EXPECT_EQ(1, aer.success); /* set to 4 because commitIDX is lower */ - CuAssertIntEquals(tc, 4, raft_get_commit_idx(r)); + EXPECT_EQ(4, raft_get_commit_idx(r)); } -void TestRaft_follower_recv_appendentries_set_commitidx_to_LeaderCommit( - CuTest * tc) +TEST(TestFollower, recv_appendentries_set_commitidx_to_LeaderCommit) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -1683,26 +1611,24 @@ void TestRaft_follower_recv_appendentries_set_commitidx_to_LeaderCommit( /* receipt of appendentries changes commit idx */ raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); + EXPECT_EQ(1, aer.success); /* set to 3 because leaderCommit is lower */ - CuAssertIntEquals(tc, 3, raft_get_commit_idx(r)); + EXPECT_EQ(3, raft_get_commit_idx(r)); } -void TestRaft_follower_recv_appendentries_failure_includes_current_idx( - CuTest * tc) +TEST(TestFollower, recv_appendentries_failure_includes_current_idx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_current_term(r, 1); - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.data.buf = "aaa"; ety.data.len = 3; ety.id = 1; @@ -1720,28 +1646,26 @@ void TestRaft_follower_recv_appendentries_failure_includes_current_idx( msg_appendentries_response_t aer; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 0 == aer.success); - CuAssertIntEquals(tc, 1, aer.current_idx); + EXPECT_FALSE(aer.success); + EXPECT_EQ(1, aer.current_idx); /* try again with a higher current_idx */ memset(&aer, 0, sizeof(aer)); ety.id = 2; raft_append_entry(r, &ety); raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 0 == aer.success); - CuAssertIntEquals(tc, 2, aer.current_idx); + EXPECT_FALSE(aer.success); + EXPECT_EQ(2, aer.current_idx); } -void TestRaft_follower_becomes_candidate_when_election_timeout_occurs( - CuTest * tc) +TEST(TestFollower, becomes_candidate_when_election_timeout_occurs) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); /* 1 second election timeout */ @@ -1754,22 +1678,20 @@ void TestRaft_follower_becomes_candidate_when_election_timeout_occurs( raft_periodic(r, max_election_timeout(1000) + 1); /* is a candidate now */ - CuAssertTrue(tc, 1 == raft_is_candidate(r)); + EXPECT_TRUE(raft_is_candidate(r)); } /* Candidate 5.2 */ -void TestRaft_follower_dont_grant_vote_if_candidate_has_a_less_complete_log( - CuTest * tc) +TEST(TestFollower, dont_grant_vote_if_candidate_has_a_less_complete_log) { msg_requestvote_t rv; msg_requestvote_response_t rvr; - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -1786,7 +1708,7 @@ void TestRaft_follower_dont_grant_vote_if_candidate_has_a_less_complete_log( raft_set_current_term(r, 1); /* server's idx are more up-to-date */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 100; ety.data.len = 4; @@ -1798,7 +1720,7 @@ void TestRaft_follower_dont_grant_vote_if_candidate_has_a_less_complete_log( /* vote not granted */ raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertTrue(tc, 0 == rvr.vote_granted); + EXPECT_FALSE(rvr.vote_granted); /* approve vote, because last_log_term is higher */ raft_set_current_term(r, 2); @@ -1808,17 +1730,15 @@ void TestRaft_follower_dont_grant_vote_if_candidate_has_a_less_complete_log( rv.last_log_idx = 1; rv.last_log_term = 3; raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); - CuAssertIntEquals(tc, 1, rvr.vote_granted); + EXPECT_EQ(1, rvr.vote_granted); } -void TestRaft_follower_recv_appendentries_heartbeat_does_not_overwrite_logs( - CuTest * tc) +TEST(TestFollower, recv_appendentries_heartbeat_does_not_overwrite_logs) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -1871,18 +1791,16 @@ void TestRaft_follower_recv_appendentries_heartbeat_does_not_overwrite_logs( /* receipt of appendentries changes commit idx */ raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertIntEquals(tc, 5, raft_get_current_idx(r)); + EXPECT_TRUE(aer.success); + EXPECT_EQ(5, raft_get_current_idx(r)); } -void TestRaft_follower_recv_appendentries_does_not_deleted_commited_entries( - CuTest * tc) +TEST(TestFollower, recv_appendentries_does_not_deleted_commited_entries) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -1946,9 +1864,9 @@ void TestRaft_follower_recv_appendentries_does_not_deleted_commited_entries( ae.leader_commit = 4; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertIntEquals(tc, 6, raft_get_current_idx(r)); - CuAssertIntEquals(tc, 4, raft_get_commit_idx(r)); + EXPECT_TRUE(aer.success); + EXPECT_EQ(6, raft_get_current_idx(r)); + EXPECT_EQ(4, raft_get_commit_idx(r)); /* The server sends a follow up AE. * This appendentry forces the node to check if it's going to delete @@ -1970,89 +1888,83 @@ void TestRaft_follower_recv_appendentries_does_not_deleted_commited_entries( ae.leader_commit = 4; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertIntEquals(tc, 6, raft_get_current_idx(r)); + EXPECT_TRUE(aer.success); + EXPECT_EQ(6, raft_get_current_idx(r)); } -void TestRaft_candidate_becomes_candidate_is_candidate(CuTest * tc) +TEST(TestCandidate, becomes_candidate_is_candidate) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_become_candidate(r); - CuAssertTrue(tc, raft_is_candidate(r)); + EXPECT_TRUE(raft_is_candidate(r)); } /* Candidate 5.2 */ -void TestRaft_follower_becoming_candidate_increments_current_term(CuTest * tc) +TEST(TestFollower, becoming_candidate_increments_current_term) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); - CuAssertTrue(tc, 0 == raft_get_current_term(r)); + EXPECT_EQ(0, raft_get_current_term(r)); raft_become_candidate(r); - CuAssertTrue(tc, 1 == raft_get_current_term(r)); + EXPECT_EQ(1, raft_get_current_term(r)); } /* Candidate 5.2 */ -void TestRaft_follower_becoming_candidate_votes_for_self(CuTest * tc) +TEST(TestFollower, becoming_candidate_votes_for_self) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); - CuAssertTrue(tc, -1 == raft_get_voted_for(r)); + EXPECT_EQ(-1, raft_get_voted_for(r)); raft_become_candidate(r); - CuAssertTrue(tc, raft_get_nodeid(r) == raft_get_voted_for(r)); - CuAssertTrue(tc, 1 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(raft_get_nodeid(r), raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_nvotes_for_me(r)); } /* Candidate 5.2 */ -void TestRaft_follower_becoming_candidate_resets_election_timeout(CuTest * tc) +TEST(TestFollower, becoming_candidate_resets_election_timeout) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_set_election_timeout(r, 1000); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); raft_periodic(r, 900); - CuAssertTrue(tc, 900 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(900, raft_get_timeout_elapsed(r)); raft_become_candidate(r); /* time is selected randomly */ - CuAssertTrue(tc, raft_get_timeout_elapsed(r) < 1000); + EXPECT_TRUE(raft_get_timeout_elapsed(r) < 1000); } -void TestRaft_follower_recv_appendentries_resets_election_timeout( - CuTest * tc) +TEST(TestFollower, recv_appendentries_resets_election_timeout) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_set_election_timeout(r, 1000); @@ -2067,22 +1979,21 @@ void TestRaft_follower_recv_appendentries_resets_election_timeout( memset(&ae, 0, sizeof(msg_appendentries_t)); ae.term = 1; raft_recv_appendentries(r, raft_get_node(r, 1), &ae, &aer); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); } /* Candidate 5.2 */ -void TestRaft_follower_becoming_candidate_requests_votes_from_other_servers( - CuTest * tc) +TEST(TestFollower, becoming_candidate_requests_votes_from_other_servers) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = sender_requestvote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = sender_requestvote; + msg_requestvote_t* rv; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); @@ -2095,27 +2006,25 @@ void TestRaft_follower_becoming_candidate_requests_votes_from_other_servers( raft_become_candidate(r); /* 2 nodes = 2 vote requests */ - rv = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != rv); - CuAssertTrue(tc, 2 != rv->term); - CuAssertTrue(tc, 3 == rv->term); + rv = (msg_requestvote_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, rv); + EXPECT_NE(2, rv->term); + EXPECT_EQ(3, rv->term); /* TODO: there should be more items */ - rv = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != rv); - CuAssertTrue(tc, 3 == rv->term); + rv = (msg_requestvote_t *)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, rv); + EXPECT_EQ(3, rv->term); } /* Candidate 5.2 */ -void TestRaft_candidate_election_timeout_and_no_leader_results_in_new_election( - CuTest * tc) +TEST(TestCandidate, election_timeout_and_no_leader_results_in_new_election) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_requestvote_response_t vr; @@ -2129,30 +2038,29 @@ void TestRaft_candidate_election_timeout_and_no_leader_results_in_new_election( /* server wants to be leader, so becomes candidate */ raft_become_candidate(r); - CuAssertTrue(tc, 1 == raft_get_current_term(r)); + EXPECT_EQ(1, raft_get_current_term(r)); /* clock over (ie. max election timeout + 1), causing new election */ raft_periodic(r, max_election_timeout(1000) + 1); - CuAssertTrue(tc, 2 == raft_get_current_term(r)); + EXPECT_EQ(2, raft_get_current_term(r)); /* receiving this vote gives the server majority */ // raft_recv_requestvote_response(r,1,&vr); -// CuAssertTrue(tc, 1 == raft_is_leader(r)); +// EXPECT_TRUE(raft_is_leader(r)); } /* Candidate 5.2 */ -void TestRaft_candidate_receives_majority_of_votes_becomes_leader(CuTest * tc) +TEST(TestCandidate, receives_majority_of_votes_becomes_leader) { msg_requestvote_response_t vr; - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -2160,12 +2068,12 @@ void TestRaft_candidate_receives_majority_of_votes_becomes_leader(CuTest * tc) raft_add_node(r, NULL, 3, 0); raft_add_node(r, NULL, 4, 0); raft_add_node(r, NULL, 5, 0); - CuAssertTrue(tc, 5 == raft_get_num_nodes(r)); + EXPECT_EQ(5, raft_get_num_nodes(r)); /* vote for self */ raft_become_candidate(r); - CuAssertTrue(tc, 1 == raft_get_current_term(r)); - CuAssertTrue(tc, 1 == raft_get_nvotes_for_me(r)); + EXPECT_EQ(1, raft_get_current_term(r)); + EXPECT_EQ(1, raft_get_nvotes_for_me(r)); /* a vote for us */ memset(&vr, 0, sizeof(msg_requestvote_response_t)); @@ -2173,25 +2081,23 @@ void TestRaft_candidate_receives_majority_of_votes_becomes_leader(CuTest * tc) vr.vote_granted = 1; /* get one vote */ raft_recv_requestvote_response(r, raft_get_node(r, 2), &vr); - CuAssertTrue(tc, 2 == raft_get_nvotes_for_me(r)); - CuAssertTrue(tc, 0 == raft_is_leader(r)); + EXPECT_EQ(2, raft_get_nvotes_for_me(r)); + EXPECT_FALSE(raft_is_leader(r)); /* get another vote * now has majority (ie. 3/5 votes) */ raft_recv_requestvote_response(r, raft_get_node(r, 3), &vr); - CuAssertTrue(tc, 1 == raft_is_leader(r)); + EXPECT_TRUE(raft_is_leader(r)); } /* Candidate 5.2 */ -void TestRaft_candidate_will_not_respond_to_voterequest_if_it_has_already_voted( - CuTest * tc) +TEST(TestCandidate, will_not_respond_to_voterequest_if_it_has_already_voted) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_requestvote_t rv; @@ -2206,21 +2112,19 @@ void TestRaft_candidate_will_not_respond_to_voterequest_if_it_has_already_voted( raft_recv_requestvote(r, raft_get_node(r, 2), &rv, &rvr); /* we've vote already, so won't respond with a vote granted... */ - CuAssertTrue(tc, 0 == rvr.vote_granted); + EXPECT_FALSE(rvr.vote_granted); } /* Candidate 5.2 */ -void TestRaft_candidate_requestvote_includes_logidx(CuTest * tc) +TEST(TestCandidate, requestvote_includes_logidx) { - raft_cbs_t funcs = { - .send_requestvote = sender_requestvote, - .log = NULL, - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.send_requestvote = sender_requestvote; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_state(r, RAFT_STATE_CANDIDATE); @@ -2228,7 +2132,7 @@ void TestRaft_candidate_requestvote_includes_logidx(CuTest * tc) raft_set_callbacks(r, &funcs, sender); raft_set_current_term(r, 5); /* 3 entries */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 100; ety.data.len = 4; @@ -2241,23 +2145,21 @@ void TestRaft_candidate_requestvote_includes_logidx(CuTest * tc) raft_append_entry(r, &ety); raft_send_requestvote(r, raft_get_node(r, 2)); - msg_requestvote_t* rv = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != rv); - CuAssertIntEquals(tc, 3, rv->last_log_idx); - CuAssertIntEquals(tc, 5, rv->term); - CuAssertIntEquals(tc, 3, rv->last_log_term); - CuAssertIntEquals(tc, 1, rv->candidate_id); + msg_requestvote_t* rv = (msg_requestvote_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, rv); + EXPECT_EQ(3, rv->last_log_idx); + EXPECT_EQ(5, rv->term); + EXPECT_EQ(3, rv->last_log_term); + EXPECT_EQ(1, rv->candidate_id); } -void TestRaft_candidate_recv_requestvote_response_becomes_follower_if_current_term_is_less_than_term( - CuTest * tc) +TEST(TestCandidate, recv_requestvote_response_becomes_follower_if_current_term_is_less_than_term) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -2266,30 +2168,28 @@ void TestRaft_candidate_recv_requestvote_response_becomes_follower_if_current_te raft_set_current_term(r, 1); raft_set_state(r, RAFT_STATE_CANDIDATE); raft_vote(r, 0); - CuAssertTrue(tc, 0 == raft_is_follower(r)); - CuAssertTrue(tc, -1 == raft_get_current_leader(r)); - CuAssertTrue(tc, 1 == raft_get_current_term(r)); + EXPECT_FALSE(raft_is_follower(r)); + EXPECT_EQ(-1, raft_get_current_leader(r)); + EXPECT_EQ(1, raft_get_current_term(r)); msg_requestvote_response_t rvr; memset(&rvr, 0, sizeof(msg_requestvote_response_t)); rvr.term = 2; rvr.vote_granted = 0; raft_recv_requestvote_response(r, raft_get_node(r, 2), &rvr); - CuAssertTrue(tc, 1 == raft_is_follower(r)); - CuAssertTrue(tc, 2 == raft_get_current_term(r)); - CuAssertTrue(tc, -1 == raft_get_voted_for(r)); + EXPECT_TRUE(raft_is_follower(r)); + EXPECT_EQ(2, raft_get_current_term(r)); + EXPECT_EQ(-1, raft_get_voted_for(r)); } /* Candidate 5.2 */ -void TestRaft_candidate_recv_appendentries_frm_leader_results_in_follower( - CuTest * tc) +TEST(TestCandidate, recv_appendentries_frm_leader_results_in_follower) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -2297,9 +2197,9 @@ void TestRaft_candidate_recv_appendentries_frm_leader_results_in_follower( raft_set_state(r, RAFT_STATE_CANDIDATE); raft_vote(r, 0); - CuAssertTrue(tc, 0 == raft_is_follower(r)); - CuAssertTrue(tc, -1 == raft_get_current_leader(r)); - CuAssertTrue(tc, 0 == raft_get_current_term(r)); + EXPECT_FALSE(raft_is_follower(r)); + EXPECT_EQ(-1, raft_get_current_leader(r)); + EXPECT_EQ(0, raft_get_current_term(r)); /* receive recent appendentries */ msg_appendentries_t ae; @@ -2308,24 +2208,22 @@ void TestRaft_candidate_recv_appendentries_frm_leader_results_in_follower( memset(&ae, 0, sizeof(msg_appendentries_t)); ae.term = 1; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == raft_is_follower(r)); + EXPECT_TRUE(raft_is_follower(r)); /* after accepting a leader, it's available as the last known leader */ - CuAssertTrue(tc, 2 == raft_get_current_leader(r)); - CuAssertTrue(tc, 1 == raft_get_current_term(r)); - CuAssertTrue(tc, -1 == raft_get_voted_for(r)); + EXPECT_EQ(2, raft_get_current_leader(r)); + EXPECT_EQ(1, raft_get_current_term(r)); + EXPECT_EQ(-1, raft_get_voted_for(r)); } /* Candidate 5.2 */ -void TestRaft_candidate_recv_appendentries_from_same_term_results_in_step_down( - CuTest * tc) +TEST(TestCandidate, recv_appendentries_from_same_term_results_in_step_down) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - .send_requestvote = __raft_send_requestvote, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; + funcs.send_requestvote = __raft_send_requestvote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -2336,8 +2234,8 @@ void TestRaft_candidate_recv_appendentries_from_same_term_results_in_step_down( raft_set_current_term(r, 1); raft_become_candidate(r); - CuAssertTrue(tc, 0 == raft_is_follower(r)); - CuAssertIntEquals(tc, 1, raft_get_voted_for(r)); + EXPECT_FALSE(raft_is_follower(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); memset(&ae, 0, sizeof(msg_appendentries_t)); ae.term = 2; @@ -2345,7 +2243,7 @@ void TestRaft_candidate_recv_appendentries_from_same_term_results_in_step_down( ae.prev_log_term = 1; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 0 == raft_is_candidate(r)); + EXPECT_FALSE(raft_is_candidate(r)); /* The election algorithm requires that votedFor always contains the node * voted for in the current term (if any), which is why it is persisted. @@ -2358,41 +2256,38 @@ void TestRaft_candidate_recv_appendentries_from_same_term_results_in_step_down( * Node self gets requestvote from other2 * Node self votes for Other2 */ - CuAssertIntEquals(tc, 1, raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); } -void TestRaft_leader_becomes_leader_is_leader(CuTest * tc) +TEST(TestLeader, becomes_leader_is_leader) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_become_leader(r); - CuAssertTrue(tc, raft_is_leader(r)); + EXPECT_TRUE(raft_is_leader(r)); } -void TestRaft_leader_becomes_leader_does_not_clear_voted_for(CuTest * tc) +TEST(TestLeader, becomes_leader_does_not_clear_voted_for) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .persist_vote = __raft_persist_vote, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.persist_vote = __raft_persist_vote; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_vote(r, raft_get_node(r, 1)); - CuAssertTrue(tc, 1 == raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); raft_become_leader(r); - CuAssertTrue(tc, 1 == raft_get_voted_for(r)); + EXPECT_EQ(1, raft_get_voted_for(r)); } -void TestRaft_leader_when_becomes_leader_all_nodes_have_nextidx_equal_to_lastlog_idx_plus_1( - CuTest * tc) +TEST(TestLeader, when_becomes_leader_all_nodes_have_nextidx_equal_to_lastlog_idx_plus_1) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -2407,22 +2302,18 @@ void TestRaft_leader_when_becomes_leader_all_nodes_have_nextidx_equal_to_lastlog for (i = 2; i <= 3; i++) { raft_node_t* p = raft_get_node(r, i); - CuAssertTrue(tc, raft_get_current_idx(r) + 1 == - raft_node_get_next_idx(p)); + EXPECT_EQ(raft_get_current_idx(r) + 1, raft_node_get_next_idx(p)); } } /* 5.2 */ -void TestRaft_leader_when_it_becomes_a_leader_sends_empty_appendentries( - CuTest * tc) +TEST(TestLeader, when_it_becomes_a_leader_sends_empty_appendentries) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); @@ -2433,21 +2324,20 @@ void TestRaft_leader_when_it_becomes_a_leader_sends_empty_appendentries( raft_become_leader(r); /* receive appendentries messages for both nodes */ - msg_appendentries_t* ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); + msg_appendentries_t* ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); } /* 5.2 * Note: commit means it's been appended to the log, not applied to the FSM */ -void TestRaft_leader_responds_to_entry_msg_when_entry_is_committed(CuTest * tc) +TEST(TestLeader, responds_to_entry_msg_when_entry_is_committed) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -2457,54 +2347,51 @@ void TestRaft_leader_responds_to_entry_msg_when_entry_is_committed(CuTest * tc) /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); - CuAssertTrue(tc, 0 == raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ - msg_entry_t ety = {}; + msg_entry_t ety = {0}; ety.id = 1; ety.data.buf = "entry"; ety.data.len = strlen("entry"); /* receive entry */ raft_recv_entry(r, &ety, &cr); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_log_count(r)); /* trigger response through commit */ raft_apply_entry(r); } -void TestRaft_non_leader_recv_entry_msg_fails(CuTest * tc) +void TestRaft_non_leader_recv_entry_msg_fails() { msg_entry_response_t cr; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_state(r, RAFT_STATE_FOLLOWER); /* entry message */ - msg_entry_t ety = {}; + msg_entry_t ety = {0}; ety.id = 1; ety.data.buf = "entry"; ety.data.len = strlen("entry"); /* receive entry */ int e = raft_recv_entry(r, &ety, &cr); - CuAssertTrue(tc, RAFT_ERR_NOT_LEADER == e); + EXPECT_EQ(RAFT_ERR_NOT_LEADER, e); } /* 5.3 */ -void TestRaft_leader_sends_appendentries_with_NextIdx_when_PrevIdx_gt_NextIdx( - CuTest * tc) +TEST(TestLeader, sends_appendentries_with_NextIdx_when_PrevIdx_gt_NextIdx) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); @@ -2517,20 +2404,17 @@ void TestRaft_leader_sends_appendentries_with_NextIdx_when_PrevIdx_gt_NextIdx( /* receive appendentries messages */ raft_send_appendentries(r, p); - msg_appendentries_t* ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); + msg_appendentries_t* ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); } -void TestRaft_leader_sends_appendentries_with_leader_commit( - CuTest * tc) +TEST(TestLeader, sends_appendentries_with_leader_commit) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); @@ -2542,7 +2426,7 @@ void TestRaft_leader_sends_appendentries_with_leader_commit( for (i=0; i<10; i++) { - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaa"; @@ -2554,21 +2438,18 @@ void TestRaft_leader_sends_appendentries_with_leader_commit( /* receive appendentries messages */ raft_send_appendentries(r, raft_get_node(r, 2)); - msg_appendentries_t* ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); - CuAssertTrue(tc, ae->leader_commit == 10); + msg_appendentries_t* ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); + EXPECT_EQ(10, ae->leader_commit); } -void TestRaft_leader_sends_appendentries_with_prevLogIdx( - CuTest * tc) +TEST(TestLeader, sends_appendentries_with_prevLogIdx) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); /* me */ raft_add_node(r, NULL, 2, 0); @@ -2578,15 +2459,15 @@ void TestRaft_leader_sends_appendentries_with_prevLogIdx( /* receive appendentries messages */ raft_send_appendentries(r, raft_get_node(r, 2)); - msg_appendentries_t* ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); - CuAssertTrue(tc, ae->prev_log_idx == 0); + msg_appendentries_t* ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); + EXPECT_EQ(0, ae->prev_log_idx); raft_node_t* n = raft_get_node(r, 2); /* add 1 entry */ /* receive appendentries messages */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 2; ety.id = 100; ety.data.len = 4; @@ -2594,32 +2475,29 @@ void TestRaft_leader_sends_appendentries_with_prevLogIdx( raft_append_entry(r, &ety); raft_node_set_next_idx(n, 1); raft_send_appendentries(r, raft_get_node(r, 2)); - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); - CuAssertTrue(tc, ae->prev_log_idx == 0); - CuAssertTrue(tc, ae->n_entries == 1); - CuAssertTrue(tc, ae->entries[0].id == 100); - CuAssertTrue(tc, ae->entries[0].term == 2); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); + EXPECT_EQ(0, ae->prev_log_idx); + EXPECT_EQ(1, ae->n_entries); + EXPECT_EQ(100, ae->entries[0].id); + EXPECT_EQ(2, ae->entries[0].term); /* set next_idx */ /* receive appendentries messages */ raft_node_set_next_idx(n, 2); raft_send_appendentries(r, raft_get_node(r, 2)); - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); - CuAssertTrue(tc, ae->prev_log_idx == 1); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); + EXPECT_EQ(1, ae->prev_log_idx); } -void TestRaft_leader_sends_appendentries_when_node_has_next_idx_of_0( - CuTest * tc) +TEST(TestLeader, sends_appendentries_when_node_has_next_idx_of_0) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); @@ -2629,35 +2507,32 @@ void TestRaft_leader_sends_appendentries_when_node_has_next_idx_of_0( /* receive appendentries messages */ raft_send_appendentries(r, raft_get_node(r, 2)); - msg_appendentries_t* ae = sender_poll_msg_data(sender); + msg_appendentries_t* ae = (msg_appendentries_t*)sender_poll_msg_data(sender); /* add an entry */ /* receive appendentries messages */ raft_node_t* n = raft_get_node(r, 2); raft_node_set_next_idx(n, 1); - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 100; ety.data.len = 4; ety.data.buf = (unsigned char*)"aaa"; raft_append_entry(r, &ety); raft_send_appendentries(r, n); - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); - CuAssertTrue(tc, ae->prev_log_idx == 0); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); + EXPECT_EQ(0, ae->prev_log_idx); } /* 5.3 */ -void TestRaft_leader_retries_appendentries_with_decremented_NextIdx_log_inconsistency( - CuTest * tc) +TEST(TestLeader, retries_appendentries_with_decremented_NextIdx_log_inconsistency) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); @@ -2667,25 +2542,24 @@ void TestRaft_leader_retries_appendentries_with_decremented_NextIdx_log_inconsis /* receive appendentries messages */ raft_send_appendentries(r, raft_get_node(r, 2)); - msg_appendentries_t* ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); + msg_appendentries_t* ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); } /* * If there exists an N such that N > commitidx, a majority * of matchidx[i] = N, and log[N].term == currentTerm: - * set commitidx = N (§5.2, §5.4). */ -void TestRaft_leader_append_entry_to_log_increases_idxno(CuTest * tc) + * set commitidx = N (§5.2, §5.4). */ +TEST(TestLeader, append_entry_to_log_increases_idxno) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; - msg_entry_t ety = {}; + msg_entry_t ety = {0}; ety.id = 1; ety.data.buf = "entry"; ety.data.len = strlen("entry"); @@ -2693,15 +2567,15 @@ void TestRaft_leader_append_entry_to_log_increases_idxno(CuTest * tc) raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_state(r, RAFT_STATE_LEADER); - CuAssertTrue(tc, 0 == raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); raft_recv_entry(r, &ety, &cr); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_log_count(r)); } #if 0 // TODO no support for duplicates -void T_estRaft_leader_doesnt_append_entry_if_unique_id_is_duplicate(CuTest * tc) +void T_estRaft_leader_doesnt_append_entry_if_unique_id_is_duplicate() { void *r; @@ -2721,29 +2595,27 @@ void T_estRaft_leader_doesnt_append_entry_if_unique_id_is_duplicate(CuTest * tc) raft_set_configuration(r, cfg, 0); raft_set_state(r, RAFT_STATE_LEADER); - CuAssertTrue(tc, 0 == raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); raft_recv_entry(r, 1, &ety); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_log_count(r)); raft_recv_entry(r, 1, &ety); - CuAssertTrue(tc, 1 == raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_log_count(r)); } #endif -void TestRaft_leader_recv_appendentries_response_increase_commit_idx_when_majority_have_entry_and_atleast_one_newer_entry( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_increase_commit_idx_when_majority_have_entry_and_atleast_one_newer_entry) { - raft_cbs_t funcs = { - .applylog = __raft_applylog, - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.applylog = __raft_applylog; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; + msg_appendentries_response_t aer; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); @@ -2759,7 +2631,7 @@ void TestRaft_leader_recv_appendentries_response_increase_commit_idx_when_majori raft_set_last_applied_idx(r, 0); /* append entries - we need two */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -2783,12 +2655,12 @@ void TestRaft_leader_recv_appendentries_response_increase_commit_idx_when_majori aer.current_idx = 1; aer.first_idx = 1; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 0, raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); raft_recv_appendentries_response(r, raft_get_node(r, 3), &aer); /* leader will now have majority followers who have appended this log */ - CuAssertIntEquals(tc, 1, raft_get_commit_idx(r)); + EXPECT_EQ(1, raft_get_commit_idx(r)); raft_periodic(r, 1); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); /* SECOND entry log application */ /* send appendentries - @@ -2801,26 +2673,23 @@ void TestRaft_leader_recv_appendentries_response_increase_commit_idx_when_majori aer.current_idx = 2; aer.first_idx = 2; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 1, raft_get_commit_idx(r)); + EXPECT_EQ(1, raft_get_commit_idx(r)); raft_recv_appendentries_response(r, raft_get_node(r, 3), &aer); /* leader will now have majority followers who have appended this log */ - CuAssertIntEquals(tc, 2, raft_get_commit_idx(r)); + EXPECT_EQ(2, raft_get_commit_idx(r)); raft_periodic(r, 1); - CuAssertIntEquals(tc, 2, raft_get_last_applied_idx(r)); + EXPECT_EQ(2, raft_get_last_applied_idx(r)); } -void TestRaft_leader_recv_appendentries_response_set_has_sufficient_logs_for_node( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_set_has_sufficient_logs_for_node) { - raft_cbs_t funcs = { - .applylog = __raft_applylog, - .persist_term = __raft_persist_term, - .node_has_sufficient_logs = __raft_node_has_sufficient_logs, - .log = NULL - }; + raft_cbs_t funcs = { 0 }; + funcs.applylog = __raft_applylog; + funcs.persist_term = __raft_persist_term; + funcs.node_has_sufficient_logs = __raft_node_has_sufficient_logs; msg_appendentries_response_t aer; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); @@ -2859,25 +2728,23 @@ void TestRaft_leader_recv_appendentries_response_set_has_sufficient_logs_for_nod raft_node_set_voting(node, 0); raft_recv_appendentries_response(r, node, &aer); - CuAssertIntEquals(tc, 1, has_sufficient_logs_flag); + EXPECT_EQ(1, has_sufficient_logs_flag); raft_recv_appendentries_response(r, node, &aer); - CuAssertIntEquals(tc, 1, has_sufficient_logs_flag); + EXPECT_EQ(1, has_sufficient_logs_flag); } -void TestRaft_leader_recv_appendentries_response_increase_commit_idx_using_voting_nodes_majority( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_increase_commit_idx_using_voting_nodes_majority) { - raft_cbs_t funcs = { - .applylog = __raft_applylog, - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.applylog = __raft_applylog; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; + msg_appendentries_response_t aer; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); @@ -2893,7 +2760,7 @@ void TestRaft_leader_recv_appendentries_response_increase_commit_idx_using_votin raft_set_last_applied_idx(r, 0); /* append entries - we need two */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -2912,24 +2779,22 @@ void TestRaft_leader_recv_appendentries_response_increase_commit_idx_using_votin aer.current_idx = 1; aer.first_idx = 1; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 1, raft_get_commit_idx(r)); + EXPECT_EQ(1, raft_get_commit_idx(r)); /* leader will now have majority followers who have appended this log */ raft_periodic(r, 1); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); } -void TestRaft_leader_recv_appendentries_response_duplicate_does_not_decrement_match_idx( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_duplicate_does_not_decrement_match_idx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; + msg_appendentries_response_t aer; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); @@ -2943,7 +2808,7 @@ void TestRaft_leader_recv_appendentries_response_duplicate_does_not_decrement_ma raft_set_last_applied_idx(r, 0); /* append entries - we need two */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -2962,7 +2827,7 @@ void TestRaft_leader_recv_appendentries_response_duplicate_does_not_decrement_ma aer.current_idx = 1; aer.first_idx = 1; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 1, raft_node_get_match_idx(raft_get_node(r, 2))); + EXPECT_EQ(1, raft_node_get_match_idx(raft_get_node(r, 2))); /* receive msg 2 */ aer.term = 1; @@ -2970,7 +2835,7 @@ void TestRaft_leader_recv_appendentries_response_duplicate_does_not_decrement_ma aer.current_idx = 2; aer.first_idx = 2; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 2, raft_node_get_match_idx(raft_get_node(r, 2))); + EXPECT_EQ(2, raft_node_get_match_idx(raft_get_node(r, 2))); /* receive msg 1 - because of duplication ie. unreliable network */ aer.term = 1; @@ -2978,22 +2843,20 @@ void TestRaft_leader_recv_appendentries_response_duplicate_does_not_decrement_ma aer.current_idx = 1; aer.first_idx = 1; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 2, raft_node_get_match_idx(raft_get_node(r, 2))); + EXPECT_EQ(2, raft_node_get_match_idx(raft_get_node(r, 2))); } -void TestRaft_leader_recv_appendentries_response_do_not_increase_commit_idx_because_of_old_terms_with_majority( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_do_not_increase_commit_idx_because_of_old_terms_with_majority) { - raft_cbs_t funcs = { - .applylog = __raft_applylog, - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.applylog = __raft_applylog; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; + msg_appendentries_response_t aer; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); @@ -3008,7 +2871,7 @@ void TestRaft_leader_recv_appendentries_response_do_not_increase_commit_idx_beca raft_set_last_applied_idx(r, 0); /* append entries - we need two */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -3033,11 +2896,11 @@ void TestRaft_leader_recv_appendentries_response_do_not_increase_commit_idx_beca aer.current_idx = 1; aer.first_idx = 1; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 0, raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); raft_recv_appendentries_response(r, raft_get_node(r, 3), &aer); - CuAssertIntEquals(tc, 0, raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); raft_periodic(r, 1); - CuAssertIntEquals(tc, 0, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_get_last_applied_idx(r)); /* SECOND entry log application */ /* send appendentries - @@ -3050,11 +2913,11 @@ void TestRaft_leader_recv_appendentries_response_do_not_increase_commit_idx_beca aer.current_idx = 2; aer.first_idx = 2; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 0, raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); raft_recv_appendentries_response(r, raft_get_node(r, 3), &aer); - CuAssertIntEquals(tc, 0, raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); raft_periodic(r, 1); - CuAssertIntEquals(tc, 0, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_get_last_applied_idx(r)); /* THIRD entry log application */ raft_send_appendentries(r, raft_get_node(r, 2)); @@ -3066,29 +2929,27 @@ void TestRaft_leader_recv_appendentries_response_do_not_increase_commit_idx_beca aer.current_idx = 3; aer.first_idx = 3; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 0, raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); raft_recv_appendentries_response(r, raft_get_node(r, 3), &aer); - CuAssertIntEquals(tc, 3, raft_get_commit_idx(r)); + EXPECT_EQ(3, raft_get_commit_idx(r)); raft_periodic(r, 1); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); raft_periodic(r, 1); - CuAssertIntEquals(tc, 2, raft_get_last_applied_idx(r)); + EXPECT_EQ(2, raft_get_last_applied_idx(r)); raft_periodic(r, 1); - CuAssertIntEquals(tc, 3, raft_get_last_applied_idx(r)); + EXPECT_EQ(3, raft_get_last_applied_idx(r)); } -void TestRaft_leader_recv_appendentries_response_jumps_to_lower_next_idx( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_jumps_to_lower_next_idx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; + msg_appendentries_response_t aer; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_callbacks(r, &funcs, sender); @@ -3097,7 +2958,7 @@ void TestRaft_leader_recv_appendentries_response_jumps_to_lower_next_idx( raft_set_commit_idx(r, 0); /* append entries */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -3118,16 +2979,16 @@ void TestRaft_leader_recv_appendentries_response_jumps_to_lower_next_idx( /* become leader sets next_idx to current_idx */ raft_become_leader(r); raft_node_t* node = raft_get_node(r, 2); - CuAssertIntEquals(tc, 5, raft_node_get_next_idx(node)); - CuAssertTrue(tc, NULL != (ae = sender_poll_msg_data(sender))); + EXPECT_EQ(5, raft_node_get_next_idx(node)); + EXPECT_NE(nullptr, (ae = (msg_appendentries_t*)sender_poll_msg_data(sender))); /* FIRST entry log application */ /* send appendentries - * server will be waiting for response */ raft_send_appendentries(r, raft_get_node(r, 2)); - CuAssertTrue(tc, NULL != (ae = sender_poll_msg_data(sender))); - CuAssertIntEquals(tc, 4, ae->prev_log_term); - CuAssertIntEquals(tc, 4, ae->prev_log_idx); + EXPECT_NE(nullptr, (ae = (msg_appendentries_t*)sender_poll_msg_data(sender))); + EXPECT_EQ(4, ae->prev_log_term); + EXPECT_EQ(4, ae->prev_log_idx); /* receive mock success responses */ memset(&aer, 0, sizeof(msg_appendentries_response_t)); @@ -3135,28 +2996,26 @@ void TestRaft_leader_recv_appendentries_response_jumps_to_lower_next_idx( aer.success = 0; aer.current_idx = 1; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 2, raft_node_get_next_idx(node)); + EXPECT_EQ(2, raft_node_get_next_idx(node)); /* see if new appendentries have appropriate values */ - CuAssertTrue(tc, NULL != (ae = sender_poll_msg_data(sender))); - CuAssertIntEquals(tc, 1, ae->prev_log_term); - CuAssertIntEquals(tc, 1, ae->prev_log_idx); + EXPECT_NE(nullptr, (ae = (msg_appendentries_t*)sender_poll_msg_data(sender))); + EXPECT_EQ(1, ae->prev_log_term); + EXPECT_EQ(1, ae->prev_log_idx); - CuAssertTrue(tc, NULL == sender_poll_msg_data(sender)); + EXPECT_EQ(nullptr, sender_poll_msg_data(sender)); } -void TestRaft_leader_recv_appendentries_response_decrements_to_lower_next_idx( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_decrements_to_lower_next_idx) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; + msg_appendentries_response_t aer; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_callbacks(r, &funcs, sender); @@ -3165,7 +3024,7 @@ void TestRaft_leader_recv_appendentries_response_decrements_to_lower_next_idx( raft_set_commit_idx(r, 0); /* append entries */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -3186,16 +3045,16 @@ void TestRaft_leader_recv_appendentries_response_decrements_to_lower_next_idx( /* become leader sets next_idx to current_idx */ raft_become_leader(r); raft_node_t* node = raft_get_node(r, 2); - CuAssertIntEquals(tc, 5, raft_node_get_next_idx(node)); - CuAssertTrue(tc, NULL != (ae = sender_poll_msg_data(sender))); + EXPECT_EQ(5, raft_node_get_next_idx(node)); + EXPECT_NE(nullptr, (ae = (msg_appendentries_t*)sender_poll_msg_data(sender))); /* FIRST entry log application */ /* send appendentries - * server will be waiting for response */ raft_send_appendentries(r, raft_get_node(r, 2)); - CuAssertTrue(tc, NULL != (ae = sender_poll_msg_data(sender))); - CuAssertIntEquals(tc, 4, ae->prev_log_term); - CuAssertIntEquals(tc, 4, ae->prev_log_idx); + EXPECT_NE(nullptr, (ae = (msg_appendentries_t*)sender_poll_msg_data(sender))); + EXPECT_EQ(4, ae->prev_log_term); + EXPECT_EQ(4, ae->prev_log_idx); /* receive mock success responses */ memset(&aer, 0, sizeof(msg_appendentries_response_t)); @@ -3203,12 +3062,12 @@ void TestRaft_leader_recv_appendentries_response_decrements_to_lower_next_idx( aer.success = 0; aer.current_idx = 4; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 4, raft_node_get_next_idx(node)); + EXPECT_EQ(4, raft_node_get_next_idx(node)); /* see if new appendentries have appropriate values */ - CuAssertTrue(tc, NULL != (ae = sender_poll_msg_data(sender))); - CuAssertIntEquals(tc, 3, ae->prev_log_term); - CuAssertIntEquals(tc, 3, ae->prev_log_idx); + EXPECT_NE(nullptr, (ae = (msg_appendentries_t*)sender_poll_msg_data(sender))); + EXPECT_EQ(3, ae->prev_log_term); + EXPECT_EQ(3, ae->prev_log_idx); /* receive mock success responses */ memset(&aer, 0, sizeof(msg_appendentries_response_t)); @@ -3216,25 +3075,24 @@ void TestRaft_leader_recv_appendentries_response_decrements_to_lower_next_idx( aer.success = 0; aer.current_idx = 4; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 3, raft_node_get_next_idx(node)); + EXPECT_EQ(3, raft_node_get_next_idx(node)); /* see if new appendentries have appropriate values */ - CuAssertTrue(tc, NULL != (ae = sender_poll_msg_data(sender))); - CuAssertIntEquals(tc, 2, ae->prev_log_term); - CuAssertIntEquals(tc, 2, ae->prev_log_idx); + EXPECT_NE(nullptr, (ae = (msg_appendentries_t*)sender_poll_msg_data(sender))); + EXPECT_EQ(2, ae->prev_log_term); + EXPECT_EQ(2, ae->prev_log_idx); - CuAssertTrue(tc, NULL == sender_poll_msg_data(sender)); + EXPECT_EQ(nullptr, sender_poll_msg_data(sender)); } -void TestRaft_leader_recv_appendentries_response_retry_only_if_leader(CuTest * tc) +TEST(TestLeader, recv_appendentries_response_retry_only_if_leader) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); @@ -3248,7 +3106,7 @@ void TestRaft_leader_recv_appendentries_response_retry_only_if_leader(CuTest * t raft_set_last_applied_idx(r, 0); /* append entries - we need two */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -3258,8 +3116,8 @@ void TestRaft_leader_recv_appendentries_response_retry_only_if_leader(CuTest * t raft_send_appendentries(r, raft_get_node(r, 2)); raft_send_appendentries(r, raft_get_node(r, 3)); - CuAssertTrue(tc, NULL != sender_poll_msg_data(sender)); - CuAssertTrue(tc, NULL != sender_poll_msg_data(sender)); + EXPECT_NE(nullptr, sender_poll_msg_data(sender)); + EXPECT_NE(nullptr, sender_poll_msg_data(sender)); raft_become_follower(r); @@ -3270,17 +3128,16 @@ void TestRaft_leader_recv_appendentries_response_retry_only_if_leader(CuTest * t aer.success = 1; aer.current_idx = 1; aer.first_idx = 1; - CuAssertTrue(tc, RAFT_ERR_NOT_LEADER == raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer)); - CuAssertTrue(tc, NULL == sender_poll_msg_data(sender)); + EXPECT_EQ(RAFT_ERR_NOT_LEADER, raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer)); + EXPECT_EQ(nullptr, sender_poll_msg_data(sender)); } -void TestRaft_leader_recv_appendentries_response_without_node_fails(CuTest * tc) +TEST(TestLeader, recv_appendentries_response_without_node_fails) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -3298,20 +3155,19 @@ void TestRaft_leader_recv_appendentries_response_without_node_fails(CuTest * tc) aer.success = 1; aer.current_idx = 0; aer.first_idx = 0; - CuAssertIntEquals(tc, -1, raft_recv_appendentries_response(r, NULL, &aer)); + EXPECT_EQ(-1, raft_recv_appendentries_response(r, NULL, &aer)); } -void TestRaft_leader_recv_entry_resets_election_timeout( - CuTest * tc) +TEST(TestLeader, recv_entry_resets_election_timeout) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_election_timeout(r, 1000); raft_set_state(r, RAFT_STATE_LEADER); raft_periodic(r, 900); /* entry message */ - msg_entry_t mety = {}; + msg_entry_t mety = {0}; mety.id = 1; mety.data.buf = "entry"; mety.data.len = strlen("entry"); @@ -3319,17 +3175,16 @@ void TestRaft_leader_recv_entry_resets_election_timeout( /* receive entry */ msg_entry_response_t cr; raft_recv_entry(r, &mety, &cr); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); } -void TestRaft_leader_recv_entry_is_committed_returns_0_if_not_committed(CuTest * tc) +TEST(TestLeader, recv_entry_is_committed_returns_0_if_not_committed) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -3340,7 +3195,7 @@ void TestRaft_leader_recv_entry_is_committed_returns_0_if_not_committed(CuTest * raft_set_commit_idx(r, 0); /* entry message */ - msg_entry_t mety = {}; + msg_entry_t mety = {0}; mety.id = 1; mety.data.buf = "entry"; mety.data.len = strlen("entry"); @@ -3348,20 +3203,19 @@ void TestRaft_leader_recv_entry_is_committed_returns_0_if_not_committed(CuTest * /* receive entry */ msg_entry_response_t cr; raft_recv_entry(r, &mety, &cr); - CuAssertTrue(tc, 0 == raft_msg_entry_response_committed(r, &cr)); + EXPECT_EQ(0, raft_msg_entry_response_committed(r, &cr)); raft_set_commit_idx(r, 1); - CuAssertTrue(tc, 1 == raft_msg_entry_response_committed(r, &cr)); + EXPECT_EQ(1, raft_msg_entry_response_committed(r, &cr)); } -void TestRaft_leader_recv_entry_is_committed_returns_neg_1_if_invalidated(CuTest * tc) +TEST(TestLeader, recv_entry_is_committed_returns_neg_1_if_invalidated) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -3372,7 +3226,7 @@ void TestRaft_leader_recv_entry_is_committed_returns_neg_1_if_invalidated(CuTest raft_set_commit_idx(r, 0); /* entry message */ - msg_entry_t mety = {}; + msg_entry_t mety = {0}; mety.id = 1; mety.data.buf = "entry"; mety.data.len = strlen("entry"); @@ -3380,11 +3234,11 @@ void TestRaft_leader_recv_entry_is_committed_returns_neg_1_if_invalidated(CuTest /* receive entry */ msg_entry_response_t cr; raft_recv_entry(r, &mety, &cr); - CuAssertTrue(tc, 0 == raft_msg_entry_response_committed(r, &cr)); - CuAssertTrue(tc, cr.term == 1); - CuAssertTrue(tc, cr.idx == 1); - CuAssertTrue(tc, 1 == raft_get_current_idx(r)); - CuAssertTrue(tc, 0 == raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_msg_entry_response_committed(r, &cr)); + EXPECT_EQ(1, cr.term); + EXPECT_EQ(1, cr.idx); + EXPECT_EQ(1, raft_get_current_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); /* append entry that invalidates entry message */ msg_appendentries_t ae; @@ -3403,20 +3257,19 @@ void TestRaft_leader_recv_entry_is_committed_returns_neg_1_if_invalidated(CuTest ae.entries = e; ae.n_entries = 1; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == aer.success); - CuAssertTrue(tc, 1 == raft_get_current_idx(r)); - CuAssertTrue(tc, 1 == raft_get_commit_idx(r)); - CuAssertTrue(tc, -1 == raft_msg_entry_response_committed(r, &cr)); + EXPECT_TRUE(aer.success); + EXPECT_EQ(1, raft_get_current_idx(r)); + EXPECT_EQ(1, raft_get_commit_idx(r)); + EXPECT_EQ(-1, raft_msg_entry_response_committed(r, &cr)); } -void TestRaft_leader_recv_entry_fails_if_prevlogidx_less_than_commit(CuTest * tc) +TEST(TestLeader, recv_entry_fails_if_prevlogidx_less_than_commit) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -3435,11 +3288,11 @@ void TestRaft_leader_recv_entry_fails_if_prevlogidx_less_than_commit(CuTest * tc /* receive entry */ msg_entry_response_t cr; raft_recv_entry(r, &mety, &cr); - CuAssertTrue(tc, 0 == raft_msg_entry_response_committed(r, &cr)); - CuAssertTrue(tc, cr.term == 2); - CuAssertTrue(tc, cr.idx == 1); - CuAssertTrue(tc, 1 == raft_get_current_idx(r)); - CuAssertTrue(tc, 0 == raft_get_commit_idx(r)); + EXPECT_EQ(0, raft_msg_entry_response_committed(r, &cr)); + EXPECT_EQ(2, cr.term); + EXPECT_EQ(1, cr.idx); + EXPECT_EQ(1, raft_get_current_idx(r)); + EXPECT_EQ(0, raft_get_commit_idx(r)); raft_set_commit_idx(r, 1); @@ -3460,19 +3313,18 @@ void TestRaft_leader_recv_entry_fails_if_prevlogidx_less_than_commit(CuTest * tc ae.entries = e; ae.n_entries = 1; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertIntEquals(tc, 0, aer.success); + EXPECT_EQ(0, aer.success); } -void TestRaft_leader_recv_entry_does_not_send_new_appendentries_to_slow_nodes(CuTest * tc) +TEST(TestLeader, recv_entry_does_not_send_new_appendentries_to_slow_nodes) { - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); raft_set_callbacks(r, &funcs, sender); @@ -3485,7 +3337,7 @@ void TestRaft_leader_recv_entry_does_not_send_new_appendentries_to_slow_nodes(Cu raft_node_set_next_idx(raft_get_node(r, 2), 1); /* append entries */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -3493,7 +3345,7 @@ void TestRaft_leader_recv_entry_does_not_send_new_appendentries_to_slow_nodes(Cu raft_append_entry(r, &ety); /* entry message */ - msg_entry_t mety = {}; + msg_entry_t mety = {0}; mety.id = 1; mety.data.buf = "entry"; mety.data.len = strlen("entry"); @@ -3504,21 +3356,18 @@ void TestRaft_leader_recv_entry_does_not_send_new_appendentries_to_slow_nodes(Cu /* check if the slow node got sent this appendentries */ msg_appendentries_t* ae; - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL == ae); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_EQ(nullptr, ae); } -void TestRaft_leader_recv_appendentries_response_failure_does_not_set_node_nextid_to_0( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_failure_does_not_set_node_nextid_to_0) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_callbacks(r, &funcs, sender); @@ -3529,7 +3378,7 @@ void TestRaft_leader_recv_appendentries_response_failure_does_not_set_node_nexti raft_set_commit_idx(r, 0); /* append entries */ - raft_entry_t ety = {}; + raft_entry_t ety = {0}; ety.term = 1; ety.id = 1; ety.data.buf = "aaaa"; @@ -3549,22 +3398,19 @@ void TestRaft_leader_recv_appendentries_response_failure_does_not_set_node_nexti aer.first_idx = 0; raft_node_t* p = raft_get_node(r, 2); raft_recv_appendentries_response(r, p, &aer); - CuAssertTrue(tc, 1 == raft_node_get_next_idx(p)); + EXPECT_EQ(1, raft_node_get_next_idx(p)); raft_recv_appendentries_response(r, p, &aer); - CuAssertTrue(tc, 1 == raft_node_get_next_idx(p)); + EXPECT_EQ(1, raft_node_get_next_idx(p)); } -void TestRaft_leader_recv_appendentries_response_increment_idx_of_node( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_increment_idx_of_node) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_callbacks(r, &funcs, sender); @@ -3574,7 +3420,7 @@ void TestRaft_leader_recv_appendentries_response_increment_idx_of_node( raft_set_current_term(r, 1); raft_node_t* p = raft_get_node(r, 2); - CuAssertTrue(tc, 1 == raft_node_get_next_idx(p)); + EXPECT_EQ(1, raft_node_get_next_idx(p)); /* receive mock success responses */ msg_appendentries_response_t aer; @@ -3583,20 +3429,17 @@ void TestRaft_leader_recv_appendentries_response_increment_idx_of_node( aer.current_idx = 0; aer.first_idx = 0; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertIntEquals(tc, 1, raft_node_get_next_idx(p)); + EXPECT_EQ(1, raft_node_get_next_idx(p)); } -void TestRaft_leader_recv_appendentries_response_drop_message_if_term_is_old( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_drop_message_if_term_is_old) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_callbacks(r, &funcs, sender); @@ -3606,7 +3449,7 @@ void TestRaft_leader_recv_appendentries_response_drop_message_if_term_is_old( raft_set_current_term(r, 2); raft_node_t* p = raft_get_node(r, 2); - CuAssertTrue(tc, 1 == raft_node_get_next_idx(p)); + EXPECT_EQ(1, raft_node_get_next_idx(p)); /* receive OLD mock success responses */ msg_appendentries_response_t aer; @@ -3615,19 +3458,16 @@ void TestRaft_leader_recv_appendentries_response_drop_message_if_term_is_old( aer.current_idx = 1; aer.first_idx = 1; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertTrue(tc, 1 == raft_node_get_next_idx(p)); + EXPECT_EQ(1, raft_node_get_next_idx(p)); } -void TestRaft_leader_recv_appendentries_response_steps_down_if_term_is_newer( - CuTest * tc) +TEST(TestLeader, recv_appendentries_response_steps_down_if_term_is_newer) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_callbacks(r, &funcs, sender); @@ -3637,7 +3477,7 @@ void TestRaft_leader_recv_appendentries_response_steps_down_if_term_is_newer( raft_set_current_term(r, 2); raft_node_t* p = raft_get_node(r, 2); - CuAssertTrue(tc, 1 == raft_node_get_next_idx(p)); + EXPECT_EQ(1, raft_node_get_next_idx(p)); /* receive NEW mock failed responses */ msg_appendentries_response_t aer; @@ -3646,18 +3486,16 @@ void TestRaft_leader_recv_appendentries_response_steps_down_if_term_is_newer( aer.current_idx = 2; aer.first_idx = 0; raft_recv_appendentries_response(r, raft_get_node(r, 2), &aer); - CuAssertTrue(tc, 1 == raft_is_follower(r)); - CuAssertTrue(tc, -1 == raft_get_current_leader(r)); + EXPECT_EQ(1, raft_is_follower(r)); + EXPECT_EQ(-1, raft_get_current_leader(r)); } -void TestRaft_leader_recv_appendentries_steps_down_if_newer( - CuTest * tc) +TEST(TestLeader, recv_appendentries_steps_down_if_newer) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -3669,8 +3507,8 @@ void TestRaft_leader_recv_appendentries_steps_down_if_newer( raft_set_state(r, RAFT_STATE_LEADER); raft_set_current_term(r, 5); /* check that node 1 considers itself the leader */ - CuAssertTrue(tc, 1 == raft_is_leader(r)); - CuAssertTrue(tc, 1 == raft_get_current_leader(r)); + EXPECT_EQ(1, raft_is_leader(r)); + EXPECT_EQ(1, raft_get_current_leader(r)); memset(&ae, 0, sizeof(msg_appendentries_t)); ae.term = 6; @@ -3679,19 +3517,17 @@ void TestRaft_leader_recv_appendentries_steps_down_if_newer( raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); /* after more recent appendentries from node 2, node 1 should - * consider node 2 the leader. */ - CuAssertTrue(tc, 1 == raft_is_follower(r)); - CuAssertTrue(tc, 2 == raft_get_current_leader(r)); + * consider node 2 the leader. */ + EXPECT_EQ(1, raft_is_follower(r)); + EXPECT_EQ(2, raft_get_current_leader(r)); } -void TestRaft_leader_recv_appendentries_steps_down_if_newer_term( - CuTest * tc) +TEST(TestLeader, recv_appendentries_steps_down_if_newer_term) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - }; + raft_cbs_t funcs = {0}; + funcs.persist_term = __raft_persist_term; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_appendentries_t ae; @@ -3709,26 +3545,23 @@ void TestRaft_leader_recv_appendentries_steps_down_if_newer_term( ae.prev_log_term = 5; raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer); - CuAssertTrue(tc, 1 == raft_is_follower(r)); + EXPECT_TRUE(raft_is_follower(r)); } -void TestRaft_leader_sends_empty_appendentries_every_request_timeout( - CuTest * tc) +TEST(TestLeader, sends_empty_appendentries_every_request_timeout) { - raft_cbs_t funcs = { - .send_appendentries = sender_appendentries, - .log = NULL - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); raft_set_election_timeout(r, 1000); raft_set_request_timeout(r, 500); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); /* candidate to leader */ raft_set_state(r, RAFT_STATE_CANDIDATE); @@ -3736,43 +3569,42 @@ void TestRaft_leader_sends_empty_appendentries_every_request_timeout( /* receive appendentries messages for both nodes */ msg_appendentries_t* ae; - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL == ae); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_EQ(nullptr, ae); /* force request timeout */ raft_periodic(r, 501); - ae = sender_poll_msg_data(sender); - CuAssertTrue(tc, NULL != ae); + ae = (msg_appendentries_t*)sender_poll_msg_data(sender); + EXPECT_NE(nullptr, ae); } /* TODO: If a server receives a request with a stale term number, it rejects the request. */ #if 0 -void T_estRaft_leader_sends_appendentries_when_receive_entry_msg(CuTest * tc) +void T_estRaft_leader_sends_appendentries_when_receive_entry_msg() #endif -void TestRaft_leader_recv_requestvote_responds_without_granting(CuTest * tc) +TEST(TestLeader, recv_requestvote_responds_without_granting) { - raft_cbs_t funcs = { - .persist_vote = __raft_persist_vote, - .persist_term = __raft_persist_term, - .send_requestvote = __raft_send_requestvote, - .send_appendentries = sender_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_vote = __raft_persist_vote; + funcs.persist_term = __raft_persist_term; + funcs.send_requestvote = __raft_send_requestvote; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); raft_set_election_timeout(r, 1000); raft_set_request_timeout(r, 500); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); raft_election_start(r); @@ -3781,34 +3613,33 @@ void TestRaft_leader_recv_requestvote_responds_without_granting(CuTest * tc) rvr.term = 1; rvr.vote_granted = 1; raft_recv_requestvote_response(r, raft_get_node(r, 2), &rvr); - CuAssertTrue(tc, 1 == raft_is_leader(r)); + EXPECT_TRUE(raft_is_leader(r)); /* receive request vote from node 3 */ msg_requestvote_t rv; memset(&rv, 0, sizeof(msg_requestvote_t)); rv.term = 1; raft_recv_requestvote(r, raft_get_node(r, 3), &rv, &rvr); - CuAssertTrue(tc, 0 == rvr.vote_granted); + EXPECT_FALSE(rvr.vote_granted); } -void TestRaft_leader_recv_requestvote_responds_with_granting_if_term_is_higher(CuTest * tc) +TEST(TestLeader, recv_requestvote_responds_with_granting_if_term_is_higher) { - raft_cbs_t funcs = { - .persist_vote = __raft_persist_vote, - .persist_term = __raft_persist_term, - .send_requestvote = __raft_send_requestvote, - .send_appendentries = sender_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.persist_vote = __raft_persist_vote; + funcs.persist_term = __raft_persist_term; + funcs.send_requestvote = __raft_send_requestvote; + funcs.send_appendentries = sender_appendentries; void *sender = sender_new(NULL); - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, sender); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_add_node(r, NULL, 3, 0); raft_set_election_timeout(r, 1000); raft_set_request_timeout(r, 500); - CuAssertTrue(tc, 0 == raft_get_timeout_elapsed(r)); + EXPECT_EQ(0, raft_get_timeout_elapsed(r)); raft_election_start(r); @@ -3817,12 +3648,12 @@ void TestRaft_leader_recv_requestvote_responds_with_granting_if_term_is_higher(C rvr.term = 1; rvr.vote_granted = 1; raft_recv_requestvote_response(r, raft_get_node(r, 2), &rvr); - CuAssertTrue(tc, 1 == raft_is_leader(r)); + EXPECT_TRUE(raft_is_leader(r)); /* receive request vote from node 3 */ msg_requestvote_t rv; memset(&rv, 0, sizeof(msg_requestvote_t)); rv.term = 2; raft_recv_requestvote(r, raft_get_node(r, 3), &rv, &rvr); - CuAssertTrue(tc, 1 == raft_is_follower(r)); + EXPECT_TRUE(raft_is_follower(r)); } diff --git a/tests/test_snapshotting.c b/tests/test_snapshotting.cpp similarity index 54% rename from tests/test_snapshotting.c rename to tests/test_snapshotting.cpp index ce3347dc..4e367e24 100644 --- a/tests/test_snapshotting.c +++ b/tests/test_snapshotting.cpp @@ -1,15 +1,19 @@ +#include + #include #include #include #include #include #include -#include "CuTest.h" +extern "C" +{ #include "raft.h" #include "raft_log.h" #include "raft_private.h" #include "mock_send_functions.h" +} static int __raft_persist_term( raft_server_t* raft, @@ -73,19 +77,18 @@ static int __raft_send_appendentries_capture(raft_server_t* raft, static int max_election_timeout(int election_timeout) { - return 2 * election_timeout; + return 2 * election_timeout; } // TODO: don't apply logs while snapshotting // TODO: don't cause elections while snapshotting -void TestRaft_leader_begin_snapshot_fails_if_no_logs_to_compact(CuTest * tc) +TEST(TestSnapshooting, leader_begin_snapshot_fails_if_no_logs_to_compact) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = {0}; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -95,7 +98,7 @@ void TestRaft_leader_begin_snapshot_fails_if_no_logs_to_compact(CuTest * tc) /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -107,20 +110,19 @@ void TestRaft_leader_begin_snapshot_fails_if_no_logs_to_compact(CuTest * tc) raft_recv_entry(r, &ety, &cr); ety.id = 2; raft_recv_entry(r, &ety, &cr); - CuAssertIntEquals(tc, 2, raft_get_log_count(r)); - CuAssertIntEquals(tc, -1, raft_begin_snapshot(r)); + EXPECT_EQ(2, raft_get_log_count(r)); + EXPECT_EQ(-1, raft_begin_snapshot(r)); raft_set_commit_idx(r, 1); - CuAssertIntEquals(tc, 0, raft_begin_snapshot(r)); + EXPECT_EQ(0, raft_begin_snapshot(r)); } -void TestRaft_leader_will_not_apply_entry_if_snapshot_is_in_progress(CuTest * tc) +TEST(TestSnapshooting, leader_will_not_apply_entry_if_snapshot_is_in_progress) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -130,7 +132,7 @@ void TestRaft_leader_will_not_apply_entry_if_snapshot_is_in_progress(CuTest * tc /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -143,22 +145,21 @@ void TestRaft_leader_will_not_apply_entry_if_snapshot_is_in_progress(CuTest * tc ety.id = 1; raft_recv_entry(r, &ety, &cr); raft_set_commit_idx(r, 1); - CuAssertIntEquals(tc, 2, raft_get_log_count(r)); + EXPECT_EQ(2, raft_get_log_count(r)); - CuAssertIntEquals(tc, 0, raft_begin_snapshot(r)); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_begin_snapshot(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); raft_set_commit_idx(r, 2); - CuAssertIntEquals(tc, -1, raft_apply_entry(r)); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); + EXPECT_EQ(-1, raft_apply_entry(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); } -void TestRaft_leader_snapshot_end_fails_if_snapshot_not_in_progress(CuTest * tc) +TEST(TestSnapshooting, leader_snapshot_end_fails_if_snapshot_not_in_progress) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); @@ -166,17 +167,16 @@ void TestRaft_leader_snapshot_end_fails_if_snapshot_not_in_progress(CuTest * tc) /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); - CuAssertIntEquals(tc, -1, raft_end_snapshot(r)); + EXPECT_EQ(0, raft_get_log_count(r)); + EXPECT_EQ(-1, raft_end_snapshot(r)); } -void TestRaft_leader_snapshot_begin_fails_if_less_than_2_logs_to_compact(CuTest * tc) +TEST(TestSnapshooting, leader_snapshot_begin_fails_if_less_than_2_logs_to_compact) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -186,7 +186,7 @@ void TestRaft_leader_snapshot_begin_fails_if_less_than_2_logs_to_compact(CuTest /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -197,18 +197,17 @@ void TestRaft_leader_snapshot_begin_fails_if_less_than_2_logs_to_compact(CuTest /* receive entry */ raft_recv_entry(r, &ety, &cr); raft_set_commit_idx(r, 1); - CuAssertIntEquals(tc, 1, raft_get_log_count(r)); - CuAssertIntEquals(tc, -1, raft_begin_snapshot(r)); + EXPECT_EQ(1, raft_get_log_count(r)); + EXPECT_EQ(-1, raft_begin_snapshot(r)); } -void TestRaft_leader_snapshot_end_succeeds_if_log_compacted(CuTest * tc) +TEST(TestSnapshooting, leader_snapshot_end_succeeds_if_log_compacted) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -219,7 +218,7 @@ void TestRaft_leader_snapshot_end_succeeds_if_log_compacted(CuTest * tc) /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); raft_set_current_term(r, 1); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -232,32 +231,31 @@ void TestRaft_leader_snapshot_end_succeeds_if_log_compacted(CuTest * tc) ety.id = 2; raft_recv_entry(r, &ety, &cr); raft_set_commit_idx(r, 1); - CuAssertIntEquals(tc, 2, raft_get_log_count(r)); - CuAssertIntEquals(tc, 1, raft_get_num_snapshottable_logs(r)); + EXPECT_EQ(2, raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_num_snapshottable_logs(r)); - CuAssertIntEquals(tc, 0, raft_begin_snapshot(r)); + EXPECT_EQ(0, raft_begin_snapshot(r)); raft_entry_t* _ety; int i = raft_get_first_entry_idx(r); for (; i < raft_get_commit_idx(r); i++) - CuAssertIntEquals(tc, 0, raft_poll_entry(r, &_ety)); - - CuAssertIntEquals(tc, 0, raft_end_snapshot(r)); - CuAssertIntEquals(tc, 0, raft_get_num_snapshottable_logs(r)); - CuAssertIntEquals(tc, 1, raft_get_log_count(r)); - CuAssertIntEquals(tc, 1, raft_get_commit_idx(r)); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); - CuAssertIntEquals(tc, 0, raft_periodic(r, 1000)); + EXPECT_EQ(0, raft_poll_entry(r, &_ety)); + + EXPECT_EQ(0, raft_end_snapshot(r)); + EXPECT_EQ(0, raft_get_num_snapshottable_logs(r)); + EXPECT_EQ(1, raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_commit_idx(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_periodic(r, 1000)); } -void TestRaft_leader_snapshot_end_succeeds_if_log_compacted2(CuTest * tc) +TEST(TestSnapshooting, leader_snapshot_end_succeeds_if_log_compacted2) { - raft_cbs_t funcs = { - .persist_term = __raft_persist_term, - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.persist_term = __raft_persist_term; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -268,7 +266,7 @@ void TestRaft_leader_snapshot_end_succeeds_if_log_compacted2(CuTest * tc) /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); raft_set_current_term(r, 1); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -283,31 +281,30 @@ void TestRaft_leader_snapshot_end_succeeds_if_log_compacted2(CuTest * tc) ety.id = 3; raft_recv_entry(r, &ety, &cr); raft_set_commit_idx(r, 2); - CuAssertIntEquals(tc, 3, raft_get_log_count(r)); - CuAssertIntEquals(tc, 2, raft_get_num_snapshottable_logs(r)); + EXPECT_EQ(3, raft_get_log_count(r)); + EXPECT_EQ(2, raft_get_num_snapshottable_logs(r)); - CuAssertIntEquals(tc, 0, raft_begin_snapshot(r)); + EXPECT_EQ(0, raft_begin_snapshot(r)); raft_entry_t* _ety; int i = raft_get_first_entry_idx(r); for (; i <= raft_get_commit_idx(r); i++) - CuAssertIntEquals(tc, 0, raft_poll_entry(r, &_ety)); - - CuAssertIntEquals(tc, 0, raft_end_snapshot(r)); - CuAssertIntEquals(tc, 0, raft_get_num_snapshottable_logs(r)); - CuAssertIntEquals(tc, 1, raft_get_log_count(r)); - CuAssertIntEquals(tc, 2, raft_get_commit_idx(r)); - CuAssertIntEquals(tc, 2, raft_get_last_applied_idx(r)); - CuAssertIntEquals(tc, 0, raft_periodic(r, 1000)); + EXPECT_EQ(0, raft_poll_entry(r, &_ety)); + + EXPECT_EQ(0, raft_end_snapshot(r)); + EXPECT_EQ(0, raft_get_num_snapshottable_logs(r)); + EXPECT_EQ(1, raft_get_log_count(r)); + EXPECT_EQ(2, raft_get_commit_idx(r)); + EXPECT_EQ(2, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_periodic(r, 1000)); } -void TestRaft_joinee_needs_to_get_snapshot(CuTest * tc) +TEST(TestSnapshooting, joinee_needs_to_get_snapshot) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -317,7 +314,7 @@ void TestRaft_joinee_needs_to_get_snapshot(CuTest * tc) /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -330,28 +327,27 @@ void TestRaft_joinee_needs_to_get_snapshot(CuTest * tc) ety.id = 2; raft_recv_entry(r, &ety, &cr); raft_set_commit_idx(r, 1); - CuAssertIntEquals(tc, 2, raft_get_log_count(r)); - CuAssertIntEquals(tc, 1, raft_get_num_snapshottable_logs(r)); + EXPECT_EQ(2, raft_get_log_count(r)); + EXPECT_EQ(1, raft_get_num_snapshottable_logs(r)); - CuAssertIntEquals(tc, 0, raft_begin_snapshot(r)); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); - CuAssertIntEquals(tc, -1, raft_apply_entry(r)); - CuAssertIntEquals(tc, 1, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_begin_snapshot(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); + EXPECT_EQ(-1, raft_apply_entry(r)); + EXPECT_EQ(1, raft_get_last_applied_idx(r)); } -void TestRaft_follower_load_from_snapshot(CuTest * tc) +TEST(TestSnapshooting, follower_load_from_snapshot) { - raft_cbs_t funcs = { - }; + raft_cbs_t funcs = {0}; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_state(r, RAFT_STATE_FOLLOWER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -359,15 +355,15 @@ void TestRaft_follower_load_from_snapshot(CuTest * tc) ety.data.buf = "entry"; ety.data.len = strlen("entry"); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); - CuAssertIntEquals(tc, 0, raft_begin_load_snapshot(r, 5, 5)); - CuAssertIntEquals(tc, 0, raft_end_load_snapshot(r)); - CuAssertIntEquals(tc, 1, raft_get_log_count(r)); - CuAssertIntEquals(tc, 0, raft_get_num_snapshottable_logs(r)); - CuAssertIntEquals(tc, 5, raft_get_commit_idx(r)); - CuAssertIntEquals(tc, 5, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_begin_load_snapshot(r, 5, 5)); + EXPECT_EQ(0, raft_end_load_snapshot(r)); + EXPECT_EQ(1, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_num_snapshottable_logs(r)); + EXPECT_EQ(5, raft_get_commit_idx(r)); + EXPECT_EQ(5, raft_get_last_applied_idx(r)); - CuAssertIntEquals(tc, 0, raft_periodic(r, 1000)); + EXPECT_EQ(0, raft_periodic(r, 1000)); /* current idx means snapshot was unnecessary */ ety.id = 2; @@ -375,23 +371,22 @@ void TestRaft_follower_load_from_snapshot(CuTest * tc) ety.id = 3; raft_append_entry(r, &ety); raft_set_commit_idx(r, 7); - CuAssertIntEquals(tc, -1, raft_begin_load_snapshot(r, 6, 5)); - CuAssertIntEquals(tc, 7, raft_get_commit_idx(r)); + EXPECT_EQ(-1, raft_begin_load_snapshot(r, 6, 5)); + EXPECT_EQ(7, raft_get_commit_idx(r)); } -void TestRaft_follower_load_from_snapshot_fails_if_already_loaded(CuTest * tc) +TEST(TestSnapshooting, follower_load_from_snapshot_fails_if_already_loaded) { - raft_cbs_t funcs = { - }; + raft_cbs_t funcs = { 0 }; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_state(r, RAFT_STATE_FOLLOWER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -399,30 +394,29 @@ void TestRaft_follower_load_from_snapshot_fails_if_already_loaded(CuTest * tc) ety.data.buf = "entry"; ety.data.len = strlen("entry"); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); - CuAssertIntEquals(tc, 0, raft_begin_load_snapshot(r, 5, 5)); - CuAssertIntEquals(tc, 0, raft_end_load_snapshot(r)); - CuAssertIntEquals(tc, 1, raft_get_log_count(r)); - CuAssertIntEquals(tc, 0, raft_get_num_snapshottable_logs(r)); - CuAssertIntEquals(tc, 5, raft_get_commit_idx(r)); - CuAssertIntEquals(tc, 5, raft_get_last_applied_idx(r)); + EXPECT_EQ(0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_begin_load_snapshot(r, 5, 5)); + EXPECT_EQ(0, raft_end_load_snapshot(r)); + EXPECT_EQ(1, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_num_snapshottable_logs(r)); + EXPECT_EQ(5, raft_get_commit_idx(r)); + EXPECT_EQ(5, raft_get_last_applied_idx(r)); - CuAssertIntEquals(tc, RAFT_ERR_SNAPSHOT_ALREADY_LOADED, raft_begin_load_snapshot(r, 5, 5)); + EXPECT_EQ(RAFT_ERR_SNAPSHOT_ALREADY_LOADED, raft_begin_load_snapshot(r, 5, 5)); } -void TestRaft_follower_load_from_snapshot_does_not_break_cluster_safety(CuTest * tc) +TEST(TestSnapshooting, follower_load_from_snapshot_does_not_break_cluster_safety) { - raft_cbs_t funcs = { - }; + raft_cbs_t funcs = { 0 }; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_state(r, RAFT_STATE_FOLLOWER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -441,22 +435,21 @@ void TestRaft_follower_load_from_snapshot_does_not_break_cluster_safety(CuTest * ety.data.len = strlen("entry"); raft_append_entry(r, &ety); - CuAssertIntEquals(tc, -1, raft_begin_load_snapshot(r, 2, 2)); + EXPECT_EQ(-1, raft_begin_load_snapshot(r, 2, 2)); } -void TestRaft_follower_load_from_snapshot_fails_if_log_is_newer(CuTest * tc) +TEST(TestSnapshooting, follower_load_from_snapshot_fails_if_log_is_newer) { - raft_cbs_t funcs = { - }; + raft_cbs_t funcs = { 0 }; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); raft_add_node(r, NULL, 1, 1); raft_add_node(r, NULL, 2, 0); raft_set_state(r, RAFT_STATE_FOLLOWER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); raft_set_last_applied_idx(r, 5); @@ -466,18 +459,17 @@ void TestRaft_follower_load_from_snapshot_fails_if_log_is_newer(CuTest * tc) ety.data.buf = "entry"; ety.data.len = strlen("entry"); - CuAssertIntEquals(tc, -1, raft_begin_load_snapshot(r, 2, 2)); + EXPECT_EQ(-1, raft_begin_load_snapshot(r, 2, 2)); } -void TestRaft_leader_sends_appendentries_when_node_next_index_was_compacted(CuTest* tc) +TEST(TestSnapshooting, leader_sends_appendentries_when_node_next_index_was_compacted) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries_capture, - }; + raft_cbs_t funcs = { 0 }; + funcs.send_appendentries = __raft_send_appendentries_capture; msg_appendentries_t ae; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, &ae); raft_node_t* node; @@ -507,31 +499,30 @@ void TestRaft_leader_sends_appendentries_when_node_next_index_was_compacted(CuTe ety.data.buf = str; ety.data.len = 3; raft_append_entry(r, &ety); - CuAssertIntEquals(tc, 3, raft_get_current_idx(r)); + EXPECT_EQ(3, raft_get_current_idx(r)); /* compact entry 1 & 2 */ - CuAssertIntEquals(tc, 0, raft_begin_load_snapshot(r, 2, 3)); - CuAssertIntEquals(tc, 0, raft_end_load_snapshot(r)); - CuAssertIntEquals(tc, 3, raft_get_current_idx(r)); + EXPECT_EQ(0, raft_begin_load_snapshot(r, 2, 3)); + EXPECT_EQ(0, raft_end_load_snapshot(r)); + EXPECT_EQ(3, raft_get_current_idx(r)); /* node wants an entry that was compacted */ raft_node_set_next_idx(node, raft_get_current_idx(r)); raft_set_state(r, RAFT_STATE_LEADER); raft_set_current_term(r, 2); - CuAssertIntEquals(tc, 0, raft_send_appendentries(r, node)); - CuAssertIntEquals(tc, 2, ae.term); - CuAssertIntEquals(tc, 2, ae.prev_log_idx); - CuAssertIntEquals(tc, 2, ae.prev_log_term); + EXPECT_EQ(0, raft_send_appendentries(r, node)); + EXPECT_EQ(2, ae.term); + EXPECT_EQ(2, ae.prev_log_idx); + EXPECT_EQ(2, ae.prev_log_term); } -void TestRaft_recv_entry_fails_if_snapshot_in_progress(CuTest* tc) +TEST(TestSnapshooting, recv_entry_fails_if_snapshot_in_progress) { - raft_cbs_t funcs = { - .send_appendentries = __raft_send_appendentries, - }; + raft_cbs_t funcs = { 0 }; + funcs.send_appendentries = __raft_send_appendentries; - void *r = raft_new(); + raft_server_t *r = raft_new(); raft_set_callbacks(r, &funcs, NULL); msg_entry_response_t cr; @@ -541,7 +532,7 @@ void TestRaft_recv_entry_fails_if_snapshot_in_progress(CuTest* tc) /* I am the leader */ raft_set_state(r, RAFT_STATE_LEADER); - CuAssertIntEquals(tc, 0, raft_get_log_count(r)); + EXPECT_EQ(0, raft_get_log_count(r)); /* entry message */ msg_entry_t ety = {}; @@ -553,12 +544,12 @@ void TestRaft_recv_entry_fails_if_snapshot_in_progress(CuTest* tc) raft_recv_entry(r, &ety, &cr); ety.id = 2; raft_recv_entry(r, &ety, &cr); - CuAssertIntEquals(tc, 2, raft_get_log_count(r)); + EXPECT_EQ(2, raft_get_log_count(r)); raft_set_commit_idx(r, 1); - CuAssertIntEquals(tc, 0, raft_begin_snapshot(r)); + EXPECT_EQ(0, raft_begin_snapshot(r)); ety.id = 3; ety.type = RAFT_LOGTYPE_ADD_NODE; - CuAssertIntEquals(tc, RAFT_ERR_SNAPSHOT_IN_PROGRESS, raft_recv_entry(r, &ety, &cr)); + EXPECT_EQ(RAFT_ERR_SNAPSHOT_IN_PROGRESS, raft_recv_entry(r, &ety, &cr)); } diff --git a/thirdparty/gtest b/thirdparty/gtest new file mode 160000 index 00000000..8f547621 --- /dev/null +++ b/thirdparty/gtest @@ -0,0 +1 @@ +Subproject commit 8f5476210303964a24516787e40d35991e0f7580 diff --git a/thirdparty/linked-list-queue b/thirdparty/linked-list-queue new file mode 160000 index 00000000..9f6ca72d --- /dev/null +++ b/thirdparty/linked-list-queue @@ -0,0 +1 @@ +Subproject commit 9f6ca72d0e168178b0faf1b35fb39941fcf7e2c6