Commit b912ff5a authored by Willem Thiart's avatar Willem Thiart
Browse files

Fix: log edge cases

The raft_log API is now being fuzzed tested. This change fixes all of
the bugs detected by the fuzzer so far.
parent f0a22790
......@@ -57,6 +57,10 @@ tests: src/raft_server.c src/raft_server_properties.c src/raft_log.c src/raft_no
./tests_main
gcov raft_server.c
.PHONY: fuzzer_tests
fuzzer_tests:
python tests/log_fuzzer.py
.PHONY: amalgamation
amalgamation:
./scripts/amalgamate.sh > raft.h
......
......@@ -5,6 +5,8 @@ typedef void* log_t;
log_t* log_new();
log_t* log_alloc(int initial_size);
void log_set_callbacks(log_t* me_, raft_cbs_t* funcs, void* raft);
void log_free(log_t* me_);
......
......@@ -18,7 +18,6 @@
#include "raft_log.h"
#define INITIAL_CAPACITY 10
#define in(x) ((log_private_t*)x)
typedef struct
{
......@@ -41,6 +40,12 @@ typedef struct
void* raft;
} log_private_t;
int mod(int a, int b)
{
int r = a % b;
return r < 0 ? r + b : r;
}
static int __ensurecapacity(log_private_t * me)
{
int i, j;
......@@ -70,14 +75,13 @@ static int __ensurecapacity(log_private_t * me)
return 0;
}
log_t* log_new()
log_t* log_alloc(int initial_size)
{
log_private_t* me = (log_private_t*)calloc(1, sizeof(log_private_t));
if (!me)
return NULL;
me->size = INITIAL_CAPACITY;
me->count = 0;
me->back = in(me)->front = 0;
me->size = initial_size;
log_clear((log_t*)me);
me->entries = (raft_entry_t*)calloc(1, sizeof(raft_entry_t) * me->size);
if (!me->entries) {
free(me);
......@@ -86,6 +90,11 @@ log_t* log_new()
return (log_t*)me;
}
log_t* log_new()
{
return log_alloc(INITIAL_CAPACITY);
}
void log_set_callbacks(log_t* me_, raft_cbs_t* funcs, void* raft)
{
log_private_t* me = (log_private_t*)me_;
......@@ -126,8 +135,9 @@ int log_append_entry(log_t* me_, raft_entry_t* c)
me->count++;
me->back++;
me->back = me->back % me->size;
return e;
return 0;
}
raft_entry_t* log_get_from_idx(log_t* me_, int idx, int *n_etys)
......@@ -164,14 +174,21 @@ raft_entry_t* log_get_at_idx(log_t* me_, int idx)
log_private_t* me = (log_private_t*)me_;
int i;
assert(0 <= idx - 1);
if (idx == 0)
return NULL;
if (me->base + me->count < idx || idx < me->base)
if (idx < me->base)
return NULL;
if (me->base + me->count < idx)
return NULL;
/* idx starts at 1 */
idx -= 1;
if (idx - me->base < me->front)
return NULL;
i = (me->front + idx - me->base) % me->size;
return &me->entries[i];
......@@ -185,23 +202,27 @@ int log_count(log_t* me_)
int log_delete(log_t* me_, int idx)
{
log_private_t* me = (log_private_t*)me_;
int end;
/* idx starts at 1 */
idx -= 1;
idx -= me->base;
if (0 == idx)
return -1;
if (idx < me->base)
idx = me->base;
for (end = log_count(me_); idx < end; idx++)
for (; idx <= me->base + me->count && me->count;)
{
int idx_tmp = me->base + me->count;
if (me->cb && me->cb->log_pop) {
int back = mod(me->back - 1, me->size);
if (me->cb && me->cb->log_pop)
{
int e = me->cb->log_pop(me->raft, raft_get_udata(me->raft),
&me->entries[me->back - 1], idx_tmp);
&me->entries[back], idx_tmp);
if (0 != e)
return e;
}
raft_pop_log(me->raft, &me->entries[me->back - 1], idx_tmp);
me->back--;
raft_pop_log(me->raft, &me->entries[back], idx_tmp);
me->back = back;
me->count--;
}
return 0;
......@@ -212,19 +233,22 @@ int log_poll(log_t * me_, void** etyp)
log_private_t* me = (log_private_t*)me_;
int idx = me->base + 1;
if (0 == log_count(me_))
if (0 == me->count)
return -1;
const void *elem = &me->entries[me->front];
if (me->cb && me->cb->log_poll) {
if (me->cb && me->cb->log_poll)
{
int e = me->cb->log_poll(me->raft, raft_get_udata(me->raft),
&me->entries[me->front], idx);
if (0 != e)
return e;
}
me->front++;
me->front = me->front % me->size;
me->count--;
me->base++;
*etyp = (void*)elem;
return 0;
}
......@@ -233,7 +257,7 @@ raft_entry_t *log_peektail(log_t * me_)
{
log_private_t* me = (log_private_t*)me_;
if (0 == log_count(me_))
if (0 == me->count)
return NULL;
if (0 == me->back)
......
......@@ -12,12 +12,14 @@
#include "raft_log.h"
#include "raft_private.h"
void TestLog_new_is_empty(CuTest * tc)
static int __logentry_get_node_id(
raft_server_t* raft,
void *udata,
raft_entry_t *ety,
int ety_idx
)
{
void *l;
l = log_new();
CuAssertTrue(tc, 0 == log_count(l));
return 0;
}
static int __log_offer(
......@@ -31,20 +33,68 @@ static int __log_offer(
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, tc);
CuAssertTrue(tc, 0 == log_append_entry(l, &e));
CuAssertTrue(tc, 1 == log_count(l));
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)
......@@ -52,17 +102,21 @@ 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;
CuAssertTrue(tc, 0 == log_append_entry(l, &e1));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e1));
e2.id = 2;
CuAssertTrue(tc, 0 == log_append_entry(l, &e2));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e2));
e3.id = 3;
CuAssertTrue(tc, 0 == log_append_entry(l, &e3));
CuAssertTrue(tc, 3 == log_count(l));
CuAssertTrue(tc, 3 == log_count(l));
CuAssertTrue(tc, e2.id == log_get_at_idx(l, 2)->id);
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)
......@@ -70,25 +124,17 @@ 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;
CuAssertTrue(tc, 0 == log_append_entry(l, &e1));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e1));
CuAssertTrue(tc, NULL == log_get_at_idx(l, 2));
}
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;
}
void TestLog_delete(CuTest * tc)
{
void *l;
......@@ -96,71 +142,226 @@ void TestLog_delete(CuTest * tc)
void* queue = llqueue_new();
void *r = raft_new();
l = log_new();
raft_cbs_t funcs = {
.log_pop = __log_pop
.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;
CuAssertTrue(tc, 0 == log_append_entry(l, &e1));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e1));
e2.id = 2;
CuAssertTrue(tc, 0 == log_append_entry(l, &e2));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e2));
e3.id = 3;
CuAssertTrue(tc, 0 == log_append_entry(l, &e3));
CuAssertTrue(tc, 3 == log_count(l));
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);
CuAssertTrue(tc, ((raft_entry_t*)llqueue_poll(queue))->id == e3.id);
CuAssertTrue(tc, 2 == log_count(l));
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);
CuAssertTrue(tc, 1 == log_count(l));
CuAssertIntEquals(tc, 1, log_count(l));
CuAssertTrue(tc, NULL == log_get_at_idx(l, 2));
log_delete(l, 1);
CuAssertTrue(tc, 0 == log_count(l));
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;
CuAssertTrue(tc, 0 == log_append_entry(l, &e1));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e1));
e2.id = 2;
CuAssertTrue(tc, 0 == log_append_entry(l, &e2));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e2));
e3.id = 3;
CuAssertTrue(tc, 0 == log_append_entry(l, &e3));
CuAssertTrue(tc, 3 == log_count(l));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e3));
CuAssertIntEquals(tc, 3, log_count(l));
/* even 3 gets deleted */
log_delete(l, 2);
CuAssertTrue(tc, 1 == log_count(l));
CuAssertTrue(tc, e1.id == log_get_at_idx(l, 1)->id);
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);
CuAssertTrue(tc, NULL == log_get_at_idx(l, 1));
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, 2));
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, 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;
CuAssertTrue(tc, 0 == log_append_entry(l, &e1));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e1));
e2.id = 2;
CuAssertTrue(tc, 0 == log_append_entry(l, &e2));
CuAssertIntEquals(tc, 0, log_append_entry(l, &e2));
e3.id = 3;
CuAssertTrue(tc, 0 == log_append_entry(l, &e3));
CuAssertTrue(tc, 3 == log_count(l));
CuAssertTrue(tc, e3.id == log_peektail(l)->id);
CuAssertIntEquals(tc, 0, log_append_entry(l, &e3));
CuAssertIntEquals(tc, 3, log_count(l));
CuAssertIntEquals(tc, e3.id, log_peektail(l)->id);
}
#if 0
......@@ -178,3 +379,156 @@ void T_estlog_cant_append_duplicates(CuTest * tc)
}
#endif
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));
}
......@@ -1528,7 +1528,7 @@ void TestRaft_follower_recv_appendentries_partial_failures(
msg_appendentries_t ae;
msg_appendentries_response_t aer;
/* Receive entry 2 and 3 of term 2. */
/* To be received: entry 2 and 3 of term 2. */
memset(&ae, 0, sizeof(msg_appendentries_t));
ae.term = 2;
ae.prev_log_idx = 1;
......@@ -1548,7 +1548,7 @@ void TestRaft_follower_recv_appendentries_partial_failures(
memset(&aer, 0, sizeof(aer));
int err = raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer);
CuAssertIntEquals(tc, RAFT_ERR_NOMEM, err);
CuAssertTrue(tc, 1 == aer.success);
CuAssertIntEquals(tc, 1, aer.success);
CuAssertIntEquals(tc, 1, aer.current_idx);
CuAssertIntEquals(tc, 2, raft_get_current_idx(r));
raft_entry_t *tmp = raft_get_entry_from_idx(r, 2);
......@@ -1561,7 +1561,7 @@ void TestRaft_follower_recv_appendentries_partial_failures(
memset(&aer, 0, sizeof(aer));
err = raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer);
CuAssertIntEquals(tc, RAFT_ERR_NOMEM, err);
CuAssertTrue(tc, 1 == aer.success);
CuAssertIntEquals(tc, 1, aer.success);
CuAssertIntEquals(tc, 2, aer.current_idx);
CuAssertIntEquals(tc, 2, raft_get_current_idx(r));
tmp = raft_get_entry_from_idx(r, 2);
......@@ -1573,7 +1573,7 @@ void TestRaft_follower_recv_appendentries_partial_failures(
memset(&aer, 0, sizeof(aer));
err = raft_recv_appendentries(r, raft_get_node(r, 2), &ae, &aer);
CuAssertIntEquals(tc, 0, err);
CuAssertTrue(tc, 1 == aer.success);
CuAssertIntEquals(tc, 1, aer.success);
CuAssertIntEquals(tc, 3, aer.current_idx);
CuAssertIntEquals(tc, 3, raft_get_current_idx(r));
}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment