Mercurial > dovecot > core-2.2
view src/dsync/test-dsync-brain-msgs.c @ 13287:957060ca5b69
Moved GUID code to liblib. Use guid_128_t type consistently everywhere.
author | Timo Sirainen <tss@iki.fi> |
---|---|
date | Thu, 25 Aug 2011 01:16:11 +0300 |
parents | 447bce266022 |
children |
line wrap: on
line source
/* Copyright (c) 2009-2011 Dovecot authors, see the included COPYING file */ #include "lib.h" #include "array.h" #include "crc32.h" #include "dsync-brain-private.h" #include "test-dsync-worker.h" #include "test-dsync-common.h" enum test_box_add_type { ADD_SRC, ADD_DEST, ADD_BOTH }; struct test_dsync_mailbox { struct dsync_brain_mailbox box; ARRAY_DEFINE(src_msgs, struct dsync_message); ARRAY_DEFINE(dest_msgs, struct dsync_message); }; ARRAY_DEFINE_TYPE(test_dsync_mailbox, struct test_dsync_mailbox); static ARRAY_TYPE(test_dsync_mailbox) mailboxes; static struct test_dsync_worker *test_src_worker, *test_dest_worker; void dsync_brain_fail(struct dsync_brain *brain ATTR_UNUSED) {} void dsync_brain_msg_sync_new_msgs(struct dsync_brain_mailbox_sync *sync ATTR_UNUSED) {} static struct test_dsync_mailbox *test_box_find(const char *name) { struct test_dsync_mailbox *boxes; unsigned int i, count; boxes = array_get_modifiable(&mailboxes, &count); for (i = 0; i < count; i++) { if (strcmp(boxes[i].box.box.name, name) == 0) return &boxes[i]; } return NULL; } static bool test_box_has_guid(const char *name, const mailbox_guid_t *guid) { const struct test_dsync_mailbox *box; box = test_box_find(name); return box != NULL && memcmp(box->box.box.mailbox_guid.guid, guid->guid, sizeof(box->box.box.mailbox_guid.guid)) == 0; } static struct test_dsync_mailbox * test_box_add(enum test_box_add_type type, const char *name) { struct test_dsync_mailbox *tbox; struct dsync_mailbox *box; tbox = test_box_find(name); if (tbox == NULL) { tbox = array_append_space(&mailboxes); i_array_init(&tbox->src_msgs, 16); i_array_init(&tbox->dest_msgs, 16); } box = i_new(struct dsync_mailbox, 1); box->name = i_strdup(name); dsync_str_sha_to_guid(t_strconcat("box-", name, NULL), &box->mailbox_guid); dsync_str_sha_to_guid(name, &box->name_sha1); box->uid_validity = crc32_str(name); box->highest_modseq = 1; switch (type) { case ADD_SRC: tbox->box.src = box; break; case ADD_DEST: tbox->box.dest = box; break; case ADD_BOTH: tbox->box.src = box; tbox->box.dest = box; break; } tbox->box.box.name = box->name; tbox->box.box.mailbox_guid = box->mailbox_guid; tbox->box.box.name_sha1 = box->name_sha1; tbox->box.box.uid_validity = box->uid_validity; return tbox; } static void test_msg_add(struct test_dsync_mailbox *box, enum test_box_add_type type, const char *guid, uint32_t uid) { static int msg_date = 0; struct dsync_message msg; memset(&msg, 0, sizeof(msg)); msg.guid = i_strdup(guid); msg.uid = uid; msg.modseq = ++box->box.box.highest_modseq; msg.save_date = ++msg_date; switch (type) { case ADD_SRC: box->box.src->highest_modseq++; box->box.src->uid_next = uid + 1; array_append(&box->src_msgs, &msg, 1); break; case ADD_DEST: box->box.dest->highest_modseq++; box->box.dest->uid_next = uid + 1; array_append(&box->dest_msgs, &msg, 1); break; case ADD_BOTH: box->box.src->highest_modseq++; box->box.dest->highest_modseq++; box->box.src->uid_next = uid + 1; box->box.dest->uid_next = uid + 1; array_append(&box->src_msgs, &msg, 1); array_append(&box->dest_msgs, &msg, 1); break; } if (box->box.box.uid_next <= uid) box->box.box.uid_next = uid + 1; } static void test_msg_set_modseq(struct test_dsync_mailbox *box, enum test_box_add_type type, uint32_t uid, uint64_t modseq) { struct dsync_message *msgs; unsigned int i, count; i_assert(modseq <= box->box.box.highest_modseq); if (type != ADD_DEST) { msgs = array_get_modifiable(&box->src_msgs, &count); for (i = 0; i < count; i++) { if (msgs[i].uid == uid) { msgs[i].modseq = modseq; break; } } i_assert(i < count); } if (type != ADD_SRC) { msgs = array_get_modifiable(&box->dest_msgs, &count); for (i = 0; i < count; i++) { if (msgs[i].uid == uid) { msgs[i].modseq = modseq; break; } } i_assert(i < count); } } static void test_msg_set_flags(struct test_dsync_mailbox *box, enum test_box_add_type type, uint32_t uid, enum mail_flags flags) { unsigned char guid_128_data[GUID_128_SIZE * 2 + 1]; struct dsync_message *msgs; unsigned int i, count; box->box.box.highest_modseq++; if (type != ADD_DEST) { box->box.src->highest_modseq = box->box.box.highest_modseq; msgs = array_get_modifiable(&box->src_msgs, &count); for (i = 0; i < count; i++) { if (msgs[i].uid == uid) { if ((flags & DSYNC_MAIL_FLAG_EXPUNGED) != 0) { msgs[i].guid = i_strdup(dsync_get_guid_128_str(msgs[i].guid, guid_128_data, sizeof(guid_128_data))); } msgs[i].flags = flags; msgs[i].modseq = box->box.src->highest_modseq; break; } } i_assert(i < count); } if (type != ADD_SRC) { box->box.dest->highest_modseq = box->box.box.highest_modseq; msgs = array_get_modifiable(&box->dest_msgs, &count); for (i = 0; i < count; i++) { if (msgs[i].uid == uid) { if ((flags & DSYNC_MAIL_FLAG_EXPUNGED) != 0) { msgs[i].guid = i_strdup(dsync_get_guid_128_str(msgs[i].guid, guid_128_data, sizeof(guid_128_data))); } msgs[i].flags = flags; msgs[i].modseq = box->box.dest->highest_modseq; break; } } i_assert(i < count); } } static void ATTR_SENTINEL test_msg_set_keywords(struct test_dsync_mailbox *box, enum test_box_add_type type, uint32_t uid, const char *kw, ...) { struct dsync_message *msgs; unsigned int i, count; va_list va; ARRAY_TYPE(const_string) keywords; t_array_init(&keywords, 8); array_append(&keywords, &kw, 1); va_start(va, kw); while ((kw = va_arg(va, const char *)) != NULL) array_append(&keywords, &kw, 1); va_end(va); (void)array_append_space(&keywords); box->box.box.highest_modseq++; if (type != ADD_DEST) { box->box.src->highest_modseq = box->box.box.highest_modseq; msgs = array_get_modifiable(&box->src_msgs, &count); for (i = 0; i < count; i++) { if (msgs[i].uid == uid) { msgs[i].keywords = array_idx(&keywords, 0); msgs[i].modseq = box->box.src->highest_modseq; break; } } i_assert(i < count); } if (type != ADD_SRC) { box->box.dest->highest_modseq = box->box.box.highest_modseq; msgs = array_get_modifiable(&box->dest_msgs, &count); for (i = 0; i < count; i++) { if (msgs[i].uid == uid) { msgs[i].keywords = array_idx(&keywords, 0); msgs[i].modseq = box->box.src->highest_modseq; break; } } i_assert(i < count); } } static void test_dsync_sync_msgs(struct test_dsync_worker *worker, bool dest) { const struct test_dsync_mailbox *boxes; const struct dsync_message *msgs; struct test_dsync_worker_msg test_msg; unsigned int i, j, box_count, msg_count; boxes = array_get(&mailboxes, &box_count); for (i = 0; i < box_count; i++) { msgs = dest ? array_get(&boxes[i].dest_msgs, &msg_count) : array_get(&boxes[i].src_msgs, &msg_count); for (j = 0; j < msg_count; j++) { test_msg.msg = msgs[j]; test_msg.mailbox_idx = i; array_append(&worker->msg_iter.msgs, &test_msg, 1); worker->worker.input_callback(worker->worker.input_context); } } worker->msg_iter.last = TRUE; worker->worker.input_callback(worker->worker.input_context); } static struct dsync_brain *test_dsync_brain_init(void) { struct dsync_brain *brain; brain = i_new(struct dsync_brain, 1); brain->src_worker = dsync_worker_init_test(); brain->dest_worker = dsync_worker_init_test(); test_src_worker = (struct test_dsync_worker *)brain->src_worker; test_dest_worker = (struct test_dsync_worker *)brain->dest_worker; return brain; } static struct dsync_brain_mailbox_sync * test_dsync_brain_sync_init(void) { ARRAY_TYPE(dsync_brain_mailbox) brain_boxes; struct dsync_brain_mailbox_sync *sync; const struct test_dsync_mailbox *tboxes; unsigned int i, count; tboxes = array_get(&mailboxes, &count); t_array_init(&brain_boxes, count); for (i = 0; i < count; i++) array_append(&brain_boxes, &tboxes[i].box, 1); sync = dsync_brain_msg_sync_init(test_dsync_brain_init(), &brain_boxes); dsync_brain_msg_sync_more(sync); test_dsync_sync_msgs(test_dest_worker, TRUE); test_dsync_sync_msgs(test_src_worker, FALSE); return sync; } static void test_dsync_brain_msg_sync_box_multi(void) { struct test_dsync_mailbox *box; struct dsync_brain_mailbox_sync *sync; struct test_dsync_msg_event msg_event; const struct dsync_brain_new_msg *new_msgs; unsigned int count; /* test that msg syncing finds and syncs all mailboxes */ test_begin("dsync brain msg sync box multi"); i_array_init(&mailboxes, 32); box = test_box_add(ADD_BOTH, "both"); test_msg_add(box, ADD_BOTH, "guid1", 1); test_msg_set_flags(box, ADD_SRC, 1, MAIL_SEEN); test_msg_set_flags(box, ADD_DEST, 1, MAIL_DRAFT); test_msg_set_flags(box, ADD_SRC, 1, MAIL_ANSWERED); box = test_box_add(ADD_SRC, "src"); test_msg_add(box, ADD_SRC, "guid2", 5); box = test_box_add(ADD_DEST, "dest"); test_msg_add(box, ADD_DEST, "guid3", 3); sync = test_dsync_brain_sync_init(); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(test_box_has_guid("both", &msg_event.mailbox)); test_assert(msg_event.msg.uid == 1); test_assert(msg_event.msg.flags == MAIL_ANSWERED); test_assert(!test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); new_msgs = array_get(&sync->dest_msg_iter->new_msgs, &count); test_assert(count == 1); test_assert(new_msgs[0].mailbox_idx == 1); test_assert(new_msgs[0].msg->uid == 5); test_assert(strcmp(new_msgs[0].msg->guid, "guid2") == 0); new_msgs = array_get(&sync->src_msg_iter->new_msgs, &count); test_assert(count == 1); test_assert(new_msgs[0].mailbox_idx == 2); test_assert(new_msgs[0].msg->uid == 3); test_assert(strcmp(new_msgs[0].msg->guid, "guid3") == 0); test_end(); } static void test_dsync_brain_msg_sync_box(enum test_box_add_type type) { struct test_dsync_mailbox *box; struct dsync_brain_mailbox_sync *sync; struct test_dsync_msg_event msg_event; const struct dsync_brain_new_msg *new_msgs; unsigned int count; i_array_init(&mailboxes, 32); box = test_box_add(type, "box1"); test_msg_add(box, type, "guid1", 1); box = test_box_add(type, "box2"); test_msg_add(box, type, "guid2", 2); sync = test_dsync_brain_sync_init(); test_assert(!test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); new_msgs = array_get(type == ADD_DEST ? &sync->src_msg_iter->new_msgs : &sync->dest_msg_iter->new_msgs, &count); test_assert(count == 2); test_assert(new_msgs[0].mailbox_idx == 0); test_assert(new_msgs[0].msg->uid == 1); test_assert(strcmp(new_msgs[0].msg->guid, "guid1") == 0); test_assert(new_msgs[1].mailbox_idx == 1); test_assert(new_msgs[1].msg->uid == 2); test_assert(strcmp(new_msgs[1].msg->guid, "guid2") == 0); } static void test_dsync_brain_msg_sync_box_single(void) { test_begin("dsync brain msg sync box src"); test_dsync_brain_msg_sync_box(ADD_SRC); test_end(); test_begin("dsync brain msg sync box dest"); test_dsync_brain_msg_sync_box(ADD_DEST); test_end(); } static void test_dsync_brain_msg_sync_existing(void) { struct test_dsync_mailbox *box; struct dsync_brain_mailbox_sync *sync; struct test_dsync_msg_event msg_event; test_begin("dsync brain msg sync existing"); i_array_init(&mailboxes, 1); box = test_box_add(ADD_BOTH, "box"); test_msg_add(box, ADD_BOTH, "guid1", 1); test_msg_add(box, ADD_BOTH, "guid2", 2); test_msg_add(box, ADD_BOTH, "guid3", 3); test_msg_add(box, ADD_BOTH, "guid5", 5); test_msg_add(box, ADD_BOTH, "guid6", 6); test_msg_add(box, ADD_BOTH, "guid9", 9); test_msg_add(box, ADD_BOTH, "guid10", 10); test_msg_add(box, ADD_BOTH, "guid11", 11); test_msg_add(box, ADD_BOTH, "guid12", 12); /* unchanged */ test_msg_set_flags(box, ADD_BOTH, 1, MAIL_SEEN); /* changed, same modseq - dest has more flags so it will be used */ test_msg_set_flags(box, ADD_SRC, 2, MAIL_ANSWERED); test_msg_set_flags(box, ADD_DEST, 2, MAIL_ANSWERED | MAIL_SEEN); test_msg_set_modseq(box, ADD_BOTH, 2, 2); /* changed, same modseq - src has more flags so it will be used */ test_msg_set_flags(box, ADD_SRC, 3, MAIL_ANSWERED | MAIL_SEEN); test_msg_set_flags(box, ADD_DEST, 3, MAIL_ANSWERED); test_msg_set_modseq(box, ADD_BOTH, 3, 3); /* changed, dest has higher modseq */ test_msg_set_flags(box, ADD_BOTH, 5, MAIL_DRAFT); test_msg_set_flags(box, ADD_DEST, 5, MAIL_FLAGGED); /* changed, src has higher modseq */ test_msg_set_flags(box, ADD_DEST, 6, MAIL_FLAGGED); test_msg_set_flags(box, ADD_SRC, 6, 0); /* keywords changed, src has higher modseq */ test_msg_set_keywords(box, ADD_SRC, 9, "hello", "world", NULL); /* flag/keyword conflict, same modseq - src has more so it will be used */ test_msg_set_keywords(box, ADD_SRC, 10, "foo", NULL); test_msg_set_flags(box, ADD_SRC, 10, MAIL_SEEN); test_msg_set_flags(box, ADD_DEST, 10, MAIL_DRAFT); test_msg_set_modseq(box, ADD_BOTH, 10, 5); /* flag/keyword conflict, same modseq - dest has more so it will be used */ test_msg_set_keywords(box, ADD_DEST, 11, "foo", NULL); test_msg_set_flags(box, ADD_SRC, 11, MAIL_SEEN); test_msg_set_flags(box, ADD_DEST, 11, MAIL_DRAFT); test_msg_set_modseq(box, ADD_BOTH, 11, 5); /* flag/keyword conflict, same modseq - both have same number of flags so src will be used */ test_msg_set_keywords(box, ADD_SRC, 12, "bar", NULL); test_msg_set_keywords(box, ADD_DEST, 12, "foo", NULL); test_msg_set_flags(box, ADD_SRC, 12, MAIL_SEEN); test_msg_set_flags(box, ADD_DEST, 12, MAIL_DRAFT); test_msg_set_modseq(box, ADD_BOTH, 12, 5); sync = test_dsync_brain_sync_init(); test_assert(array_count(&sync->src_msg_iter->new_msgs) == 0); test_assert(array_count(&sync->dest_msg_iter->new_msgs) == 0); test_assert(test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 2); test_assert(msg_event.msg.flags == (MAIL_ANSWERED | MAIL_SEEN)); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 3); test_assert(msg_event.msg.flags == (MAIL_ANSWERED | MAIL_SEEN)); test_assert(test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 5); test_assert(msg_event.msg.flags == MAIL_FLAGGED); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 6); test_assert(msg_event.msg.flags == 0); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 9); test_assert(msg_event.msg.flags == 0); test_assert(strcmp(msg_event.msg.keywords[0], "hello") == 0); test_assert(strcmp(msg_event.msg.keywords[1], "world") == 0); test_assert(msg_event.msg.keywords[2] == NULL); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 10); test_assert(msg_event.msg.flags == MAIL_SEEN); test_assert(strcmp(msg_event.msg.keywords[0], "foo") == 0); test_assert(msg_event.msg.keywords[1] == NULL); test_assert(test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 11); test_assert(msg_event.msg.flags == MAIL_DRAFT); test_assert(strcmp(msg_event.msg.keywords[0], "foo") == 0); test_assert(msg_event.msg.keywords[1] == NULL); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_UPDATE); test_assert(msg_event.msg.uid == 12); test_assert(msg_event.msg.flags == MAIL_SEEN); test_assert(strcmp(msg_event.msg.keywords[0], "bar") == 0); test_assert(msg_event.msg.keywords[1] == NULL); test_assert(!test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(!test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_end(); } static void test_dsync_brain_msg_sync_expunges(void) { struct test_dsync_mailbox *box; struct dsync_brain_mailbox_sync *sync; struct test_dsync_msg_event msg_event; test_begin("dsync brain msg sync expunges"); i_array_init(&mailboxes, 1); box = test_box_add(ADD_BOTH, "box"); /* expunged from dest */ test_msg_add(box, ADD_SRC, "guid1", 1); /* expunged from src */ test_msg_add(box, ADD_DEST, "guid2", 2); /* expunged from dest with expunge record */ test_msg_add(box, ADD_BOTH, "guid3", 3); test_msg_set_flags(box, ADD_DEST, 3, DSYNC_MAIL_FLAG_EXPUNGED); /* expunged from src with expunge record */ test_msg_add(box, ADD_BOTH, "guid4", 4); test_msg_set_flags(box, ADD_SRC, 4, DSYNC_MAIL_FLAG_EXPUNGED); /* expunged from both, with expunge record in src */ test_msg_add(box, ADD_SRC, "guid5", 5); test_msg_set_flags(box, ADD_SRC, 5, DSYNC_MAIL_FLAG_EXPUNGED); /* expunged from both, with expunge record in dest */ test_msg_add(box, ADD_DEST, "guid6", 6); test_msg_set_flags(box, ADD_DEST, 6, DSYNC_MAIL_FLAG_EXPUNGED); /* expunged from both, with expunge record in both */ test_msg_add(box, ADD_BOTH, "guid7", 7); test_msg_set_flags(box, ADD_BOTH, 7, DSYNC_MAIL_FLAG_EXPUNGED); sync = test_dsync_brain_sync_init(); test_assert(array_count(&sync->src_msg_iter->new_msgs) == 0); test_assert(array_count(&sync->dest_msg_iter->new_msgs) == 0); test_assert(test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_EXPUNGE); test_assert(msg_event.msg.uid == 1); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_EXPUNGE); test_assert(msg_event.msg.uid == 2); test_assert(test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_EXPUNGE); test_assert(msg_event.msg.uid == 3); test_assert(test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_assert(msg_event.type == LAST_MSG_TYPE_EXPUNGE); test_assert(msg_event.msg.uid == 4); test_assert(!test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(!test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); test_end(); } static void test_dsync_brain_msg_sync_uid_conflicts(void) { struct test_dsync_mailbox *box; struct dsync_brain_mailbox_sync *sync; struct test_dsync_msg_event msg_event; const struct dsync_brain_uid_conflict *conflicts; const struct dsync_brain_new_msg *src_msgs, *dest_msgs; unsigned int src_count, dest_count; test_begin("dsync brain msg sync uid conflicts"); i_array_init(&mailboxes, 16); /* existing guid mismatch */ box = test_box_add(ADD_BOTH, "box1"); test_msg_add(box, ADD_SRC, "guid1", 1); test_msg_add(box, ADD_DEST, "guid2", 1); /* preserve uid */ test_msg_add(box, ADD_BOTH, "guid3", 3); /* extra message in src */ test_msg_add(box, ADD_SRC, "guid4", 4); /* extra message in dest */ test_msg_add(box, ADD_DEST, "guid5", 5); /* conflict in expunged message expunged in dest */ test_msg_add(box, ADD_SRC, "guid6", 6); test_msg_add(box, ADD_DEST, "guid7", 6); test_msg_set_flags(box, ADD_DEST, 6, DSYNC_MAIL_FLAG_EXPUNGED); /* conflict in expunged message expunged in src */ test_msg_add(box, ADD_SRC, "guid8", 8); test_msg_set_flags(box, ADD_SRC, 8, DSYNC_MAIL_FLAG_EXPUNGED); test_msg_add(box, ADD_DEST, "guid9", 8); /* conflict in expunged message expunged in both */ test_msg_add(box, ADD_SRC, "guid10", 10); test_msg_set_flags(box, ADD_SRC, 10, DSYNC_MAIL_FLAG_EXPUNGED); test_msg_add(box, ADD_DEST, "guid11", 10); test_msg_set_flags(box, ADD_DEST, 10, DSYNC_MAIL_FLAG_EXPUNGED); sync = test_dsync_brain_sync_init(); conflicts = array_get(&sync->src_msg_iter->uid_conflicts, &src_count); test_assert(src_count == 3); test_assert(conflicts[0].old_uid == 1); test_assert(conflicts[0].new_uid == 12); test_assert(conflicts[1].old_uid == 4); test_assert(conflicts[1].new_uid == 13); test_assert(conflicts[2].old_uid == 6); test_assert(conflicts[2].new_uid == 15); conflicts = array_get(&sync->dest_msg_iter->uid_conflicts, &dest_count); test_assert(dest_count == 3); test_assert(conflicts[0].old_uid == 1); test_assert(conflicts[0].new_uid == 11); test_assert(conflicts[1].old_uid == 5); test_assert(conflicts[1].new_uid == 14); test_assert(conflicts[2].old_uid == 8); test_assert(conflicts[2].new_uid == 16); test_assert(!test_dsync_worker_next_msg_event(test_src_worker, &msg_event)); test_assert(!test_dsync_worker_next_msg_event(test_dest_worker, &msg_event)); src_msgs = array_get(&sync->src_msg_iter->new_msgs, &src_count); dest_msgs = array_get(&sync->dest_msg_iter->new_msgs, &dest_count); test_assert(src_count == 3); test_assert(dest_count == 3); test_assert(dest_msgs[0].msg->uid == 12); test_assert(strcmp(dest_msgs[0].msg->guid, "guid1") == 0); test_assert(src_msgs[0].msg->uid == 11); test_assert(strcmp(src_msgs[0].msg->guid, "guid2") == 0); test_assert(dest_msgs[1].msg->uid == 13); test_assert(strcmp(dest_msgs[1].msg->guid, "guid4") == 0); test_assert(src_msgs[1].msg->uid == 14); test_assert(strcmp(src_msgs[1].msg->guid, "guid5") == 0); test_assert(dest_msgs[2].msg->uid == 15); test_assert(strcmp(dest_msgs[2].msg->guid, "guid6") == 0); test_assert(src_msgs[2].msg->uid == 16); test_assert(strcmp(src_msgs[2].msg->guid, "guid9") == 0); test_end(); } int main(void) { static void (*test_functions[])(void) = { test_dsync_brain_msg_sync_box_multi, test_dsync_brain_msg_sync_box_single, test_dsync_brain_msg_sync_existing, test_dsync_brain_msg_sync_expunges, test_dsync_brain_msg_sync_uid_conflicts, NULL }; return test_run(test_functions); }