2 protocol tests - common functions
4 Copyright (C) Amitay Isaacs 2015-2017
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include "system/network.h"
25 #include "protocol/protocol_api.h"
27 #include "tests/src/protocol_common.h"
29 uint8_t BUFFER[1024*1024];
32 * Functions to generation random data
37 return random() % max;
42 uint8_t val = rand_int(256) & 0xff;
48 uint16_t val = rand_int(0xffff) & 0xffff;
54 return INT_MIN + random();
64 uint64_t t = random();
65 t = (t << 32) | random();
69 double rand_double(void)
71 return 1.0 / rand64();
74 void fill_buffer(void *p, size_t len)
79 for (i=0; i<len; i++) {
84 void verify_buffer(void *p1, void *p2, size_t len)
87 assert(memcmp(p1, p2, len) == 0);
91 static void fill_string(char *p, size_t len)
95 for (i=0; i<len-1; i++) {
96 p[i] = 'A' + rand_int(26);
101 static void verify_string(const char *p1, const char *p2)
103 assert(strlen(p1) == strlen(p2));
104 assert(strcmp(p1, p2) == 0);
107 void fill_ctdb_uint8(uint8_t *p)
112 void verify_ctdb_uint8(uint8_t *p1, uint8_t *p2)
117 void fill_ctdb_uint16(uint16_t *p)
122 void verify_ctdb_uint16(uint16_t *p1, uint16_t *p2)
127 void fill_ctdb_int32(int32_t *p)
132 void verify_ctdb_int32(int32_t *p1, int32_t *p2)
137 void fill_ctdb_uint32(uint32_t *p)
142 void verify_ctdb_uint32(uint32_t *p1, uint32_t *p2)
147 void fill_ctdb_uint64(uint64_t *p)
152 void verify_ctdb_uint64(uint64_t *p1, uint64_t *p2)
157 void fill_ctdb_double(double *p)
162 void verify_ctdb_double(double *p1, double *p2)
167 void fill_ctdb_bool(bool *p)
169 if (rand_int(2) == 0) {
176 void verify_ctdb_bool(bool *p1, bool *p2)
181 void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **p)
186 len = rand_int(1024) + 2;
187 str = talloc_size(mem_ctx, len+1);
190 fill_string(str, len);
194 void verify_ctdb_string(const char **p1, const char **p2)
196 if (*p1 == NULL || *p2 == NULL) {
199 verify_string(*p1, *p2);
203 void fill_ctdb_stringn(TALLOC_CTX *mem_ctx, const char **p)
205 fill_ctdb_string(mem_ctx, p);
208 void verify_ctdb_stringn(const char **p1, const char **p2)
210 verify_ctdb_string(p1, p2);
213 void fill_ctdb_pid(pid_t *p)
218 void verify_ctdb_pid(pid_t *p1, pid_t *p2)
223 void fill_tdb_data_nonnull(TALLOC_CTX *mem_ctx, TDB_DATA *p)
225 p->dsize = rand_int(1024) + 1;
226 p->dptr = talloc_array(mem_ctx, uint8_t, p->dsize);
227 assert(p->dptr != NULL);
228 fill_buffer(p->dptr, p->dsize);
231 void fill_tdb_data(TALLOC_CTX *mem_ctx, TDB_DATA *p)
233 if (rand_int(5) == 0) {
237 fill_tdb_data_nonnull(mem_ctx, p);
241 void verify_tdb_data(TDB_DATA *p1, TDB_DATA *p2)
243 assert(p1->dsize == p2->dsize);
244 verify_buffer(p1->dptr, p2->dptr, p1->dsize);
247 void fill_ctdb_statistics(TALLOC_CTX *mem_ctx, struct ctdb_statistics *p)
249 fill_buffer((uint8_t *)p, sizeof(struct ctdb_statistics));
252 void verify_ctdb_statistics(struct ctdb_statistics *p1,
253 struct ctdb_statistics *p2)
255 verify_buffer(p1, p2, sizeof(struct ctdb_statistics));
258 void fill_ctdb_vnn_map(TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *p)
262 p->generation = rand32();
263 p->size = rand_int(20);
265 p->map = talloc_array(mem_ctx, uint32_t, p->size);
266 assert(p->map != NULL);
268 for (i=0; i<p->size; i++) {
269 p->map[i] = rand32();
276 void verify_ctdb_vnn_map(struct ctdb_vnn_map *p1, struct ctdb_vnn_map *p2)
280 assert(p1->generation == p2->generation);
281 assert(p1->size == p2->size);
282 for (i=0; i<p1->size; i++) {
283 assert(p1->map[i] == p2->map[i]);
287 void fill_ctdb_dbid(TALLOC_CTX *mem_ctx, struct ctdb_dbid *p)
293 void verify_ctdb_dbid(struct ctdb_dbid *p1, struct ctdb_dbid *p2)
295 assert(p1->db_id == p2->db_id);
296 assert(p1->flags == p2->flags);
299 void fill_ctdb_dbid_map(TALLOC_CTX *mem_ctx, struct ctdb_dbid_map *p)
303 p->num = rand_int(40);
305 p->dbs = talloc_array(mem_ctx, struct ctdb_dbid, p->num);
306 assert(p->dbs != NULL);
307 for (i=0; i<p->num; i++) {
308 fill_ctdb_dbid(mem_ctx, &p->dbs[i]);
315 void verify_ctdb_dbid_map(struct ctdb_dbid_map *p1, struct ctdb_dbid_map *p2)
319 assert(p1->num == p2->num);
320 for (i=0; i<p1->num; i++) {
321 verify_ctdb_dbid(&p1->dbs[i], &p2->dbs[i]);
325 void fill_ctdb_pulldb(TALLOC_CTX *mem_ctx, struct ctdb_pulldb *p)
328 p->lmaster = rand32();
331 void verify_ctdb_pulldb(struct ctdb_pulldb *p1, struct ctdb_pulldb *p2)
333 assert(p1->db_id == p2->db_id);
334 assert(p1->lmaster == p2->lmaster);
337 void fill_ctdb_pulldb_ext(TALLOC_CTX *mem_ctx, struct ctdb_pulldb_ext *p)
340 p->lmaster = rand32();
344 void verify_ctdb_pulldb_ext(struct ctdb_pulldb_ext *p1,
345 struct ctdb_pulldb_ext *p2)
347 assert(p1->db_id == p2->db_id);
348 assert(p1->lmaster == p2->lmaster);
349 assert(p1->srvid == p2->srvid);
352 void fill_ctdb_ltdb_header(TALLOC_CTX *mem_ctx, struct ctdb_ltdb_header *p)
355 p->dmaster = rand32();
359 void verify_ctdb_ltdb_header(struct ctdb_ltdb_header *p1,
360 struct ctdb_ltdb_header *p2)
362 assert(p1->rsn == p2->rsn);
363 assert(p1->dmaster == p2->dmaster);
364 assert(p1->flags == p2->flags);
367 void fill_ctdb_rec_data(TALLOC_CTX *mem_ctx, struct ctdb_rec_data *p)
370 if (p->reqid % 5 == 0) {
371 p->header = talloc(mem_ctx, struct ctdb_ltdb_header);
372 assert(p->header != NULL);
373 fill_ctdb_ltdb_header(mem_ctx, p->header);
377 fill_tdb_data_nonnull(mem_ctx, &p->key);
378 fill_tdb_data(mem_ctx, &p->data);
381 void verify_ctdb_rec_data(struct ctdb_rec_data *p1, struct ctdb_rec_data *p2)
383 struct ctdb_ltdb_header header;
385 assert(p1->reqid == p2->reqid);
386 if (p1->header != NULL) {
387 assert(ctdb_ltdb_header_extract(&p2->data, &header) == 0);
388 verify_ctdb_ltdb_header(p1->header, &header);
390 verify_tdb_data(&p1->key, &p2->key);
391 verify_tdb_data(&p1->data, &p2->data);
394 void fill_ctdb_rec_buffer(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *p)
396 struct ctdb_rec_data rec;
405 count = rand_int(100);
407 for (i=0; i<count; i++) {
408 fill_ctdb_rec_data(mem_ctx, &rec);
409 ret = ctdb_rec_buffer_add(mem_ctx, p, rec.reqid,
417 void verify_ctdb_rec_buffer(struct ctdb_rec_buffer *p1,
418 struct ctdb_rec_buffer *p2)
420 assert(p1->db_id == p2->db_id);
421 assert(p1->count == p2->count);
422 assert(p1->buflen == p2->buflen);
423 verify_buffer(p1->buf, p2->buf, p1->buflen);
426 void fill_ctdb_traverse_start(TALLOC_CTX *mem_ctx,
427 struct ctdb_traverse_start *p)
434 void verify_ctdb_traverse_start(struct ctdb_traverse_start *p1,
435 struct ctdb_traverse_start *p2)
437 assert(p1->db_id == p2->db_id);
438 assert(p1->reqid == p2->reqid);
439 assert(p1->srvid == p2->srvid);
442 void fill_ctdb_traverse_all(TALLOC_CTX *mem_ctx,
443 struct ctdb_traverse_all *p)
448 p->client_reqid = rand32();
452 void verify_ctdb_traverse_all(struct ctdb_traverse_all *p1,
453 struct ctdb_traverse_all *p2)
455 assert(p1->db_id == p2->db_id);
456 assert(p1->reqid == p2->reqid);
457 assert(p1->pnn == p2->pnn);
458 assert(p1->client_reqid == p2->client_reqid);
459 assert(p1->srvid == p2->srvid);
462 void fill_ctdb_traverse_start_ext(TALLOC_CTX *mem_ctx,
463 struct ctdb_traverse_start_ext *p)
468 p->withemptyrecords = rand_int(2);
471 void verify_ctdb_traverse_start_ext(struct ctdb_traverse_start_ext *p1,
472 struct ctdb_traverse_start_ext *p2)
474 assert(p1->db_id == p2->db_id);
475 assert(p1->reqid == p2->reqid);
476 assert(p1->srvid == p2->srvid);
477 assert(p1->withemptyrecords == p2->withemptyrecords);
480 void fill_ctdb_traverse_all_ext(TALLOC_CTX *mem_ctx,
481 struct ctdb_traverse_all_ext *p)
486 p->client_reqid = rand32();
488 p->withemptyrecords = rand_int(2);
491 void verify_ctdb_traverse_all_ext(struct ctdb_traverse_all_ext *p1,
492 struct ctdb_traverse_all_ext *p2)
494 assert(p1->db_id == p2->db_id);
495 assert(p1->reqid == p2->reqid);
496 assert(p1->pnn == p2->pnn);
497 assert(p1->client_reqid == p2->client_reqid);
498 assert(p1->srvid == p2->srvid);
499 assert(p1->withemptyrecords == p2->withemptyrecords);
502 void fill_ctdb_sock_addr(TALLOC_CTX *mem_ctx, ctdb_sock_addr *p)
504 if (rand_int(2) == 0) {
505 p->ip.sin_family = AF_INET;
506 p->ip.sin_port = rand_int(65535);
507 fill_buffer(&p->ip.sin_addr, sizeof(struct in_addr));
509 p->ip6.sin6_family = AF_INET6;
510 p->ip6.sin6_port = rand_int(65535);
511 fill_buffer(&p->ip6.sin6_addr, sizeof(struct in6_addr));
515 void verify_ctdb_sock_addr(ctdb_sock_addr *p1, ctdb_sock_addr *p2)
517 assert(p1->sa.sa_family == p2->sa.sa_family);
518 if (p1->sa.sa_family == AF_INET) {
519 assert(p1->ip.sin_port == p2->ip.sin_port);
520 verify_buffer(&p1->ip.sin_addr, &p2->ip.sin_addr,
521 sizeof(struct in_addr));
523 assert(p1->ip6.sin6_port == p2->ip6.sin6_port);
524 verify_buffer(&p1->ip6.sin6_addr, &p2->ip6.sin6_addr,
525 sizeof(struct in6_addr));
529 void fill_ctdb_connection(TALLOC_CTX *mem_ctx, struct ctdb_connection *p)
531 fill_ctdb_sock_addr(mem_ctx, &p->src);
532 fill_ctdb_sock_addr(mem_ctx, &p->dst);
535 void verify_ctdb_connection(struct ctdb_connection *p1,
536 struct ctdb_connection *p2)
538 verify_ctdb_sock_addr(&p1->src, &p2->src);
539 verify_ctdb_sock_addr(&p1->dst, &p2->dst);
542 void fill_ctdb_tunable(TALLOC_CTX *mem_ctx, struct ctdb_tunable *p)
544 fill_ctdb_string(mem_ctx, &p->name);
548 void verify_ctdb_tunable(struct ctdb_tunable *p1, struct ctdb_tunable *p2)
550 verify_ctdb_string(&p1->name, &p2->name);
551 assert(p1->value == p2->value);
554 void fill_ctdb_node_flag_change(TALLOC_CTX *mem_ctx,
555 struct ctdb_node_flag_change *p)
558 p->new_flags = rand32();
559 p->old_flags = rand32();
562 void verify_ctdb_node_flag_change(struct ctdb_node_flag_change *p1,
563 struct ctdb_node_flag_change *p2)
565 assert(p1->pnn == p2->pnn);
566 assert(p1->new_flags == p2->new_flags);
567 assert(p1->old_flags == p2->old_flags);
570 void fill_ctdb_var_list(TALLOC_CTX *mem_ctx, struct ctdb_var_list *p)
574 p->count = rand_int(100) + 1;
575 p->var = talloc_array(mem_ctx, const char *, p->count);
576 for (i=0; i<p->count; i++) {
577 fill_ctdb_string(p->var, &p->var[i]);
581 void verify_ctdb_var_list(struct ctdb_var_list *p1, struct ctdb_var_list *p2)
585 assert(p1->count == p2->count);
586 for (i=0; i<p1->count; i++) {
587 verify_ctdb_string(&p1->var[i], &p2->var[i]);
591 void fill_ctdb_tunable_list(TALLOC_CTX *mem_ctx, struct ctdb_tunable_list *p)
593 fill_buffer(p, sizeof(struct ctdb_tunable_list));
596 void verify_ctdb_tunable_list(struct ctdb_tunable_list *p1,
597 struct ctdb_tunable_list *p2)
599 verify_buffer(p1, p2, sizeof(struct ctdb_tunable_list));
602 void fill_ctdb_tickle_list(TALLOC_CTX *mem_ctx, struct ctdb_tickle_list *p)
606 fill_ctdb_sock_addr(mem_ctx, &p->addr);
607 p->num = rand_int(1000);
609 p->conn = talloc_array(mem_ctx, struct ctdb_connection, p->num);
610 assert(p->conn != NULL);
611 for (i=0; i<p->num; i++) {
612 fill_ctdb_connection(mem_ctx, &p->conn[i]);
619 void verify_ctdb_tickle_list(struct ctdb_tickle_list *p1,
620 struct ctdb_tickle_list *p2)
624 verify_ctdb_sock_addr(&p1->addr, &p2->addr);
625 assert(p1->num == p2->num);
626 for (i=0; i<p1->num; i++) {
627 verify_ctdb_connection(&p1->conn[i], &p2->conn[i]);
631 void fill_ctdb_addr_info(TALLOC_CTX *mem_ctx, struct ctdb_addr_info *p)
633 fill_ctdb_sock_addr(mem_ctx, &p->addr);
634 p->mask = rand_int(33);
635 if (rand_int(2) == 0) {
638 fill_ctdb_string(mem_ctx, &p->iface);
642 void verify_ctdb_addr_info(struct ctdb_addr_info *p1,
643 struct ctdb_addr_info *p2)
645 verify_ctdb_sock_addr(&p1->addr, &p2->addr);
646 assert(p1->mask == p2->mask);
647 verify_ctdb_string(&p1->iface, &p2->iface);
650 void fill_ctdb_transdb(TALLOC_CTX *mem_ctx, struct ctdb_transdb *p)
656 void verify_ctdb_transdb(struct ctdb_transdb *p1, struct ctdb_transdb *p2)
658 assert(p1->db_id == p2->db_id);
659 assert(p1->tid == p2->tid);
662 void fill_ctdb_uptime(TALLOC_CTX *mem_ctx, struct ctdb_uptime *p)
664 fill_buffer(p, sizeof(struct ctdb_uptime));
667 void verify_ctdb_uptime(struct ctdb_uptime *p1, struct ctdb_uptime *p2)
669 verify_buffer(p1, p2, sizeof(struct ctdb_uptime));
672 void fill_ctdb_public_ip(TALLOC_CTX *mem_ctx, struct ctdb_public_ip *p)
675 fill_ctdb_sock_addr(mem_ctx, &p->addr);
678 void verify_ctdb_public_ip(struct ctdb_public_ip *p1,
679 struct ctdb_public_ip *p2)
681 assert(p1->pnn == p2->pnn);
682 verify_ctdb_sock_addr(&p1->addr, &p2->addr);
685 void fill_ctdb_public_ip_list(TALLOC_CTX *mem_ctx,
686 struct ctdb_public_ip_list *p)
690 p->num = rand_int(32);
692 p->ip = talloc_array(mem_ctx, struct ctdb_public_ip, p->num);
693 assert(p->ip != NULL);
694 for (i=0; i<p->num; i++) {
695 fill_ctdb_public_ip(mem_ctx, &p->ip[i]);
702 void verify_ctdb_public_ip_list(struct ctdb_public_ip_list *p1,
703 struct ctdb_public_ip_list *p2)
707 assert(p1->num == p2->num);
708 for (i=0; i<p1->num; i++) {
709 verify_ctdb_public_ip(&p1->ip[i], &p2->ip[i]);
713 void fill_ctdb_node_and_flags(TALLOC_CTX *mem_ctx,
714 struct ctdb_node_and_flags *p)
718 fill_ctdb_sock_addr(mem_ctx, &p->addr);
721 void verify_ctdb_node_and_flags(struct ctdb_node_and_flags *p1,
722 struct ctdb_node_and_flags *p2)
724 assert(p1->pnn == p2->pnn);
725 assert(p1->flags == p2->flags);
726 verify_ctdb_sock_addr(&p1->addr, &p2->addr);
729 void fill_ctdb_node_map(TALLOC_CTX *mem_ctx, struct ctdb_node_map *p)
733 p->num = rand_int(32);
735 p->node = talloc_array(mem_ctx, struct ctdb_node_and_flags,
737 assert(p->node != NULL);
738 for (i=0; i<p->num; i++) {
739 fill_ctdb_node_and_flags(mem_ctx, &p->node[i]);
746 void verify_ctdb_node_map(struct ctdb_node_map *p1, struct ctdb_node_map *p2)
750 assert(p1->num == p2->num);
751 for (i=0; i<p1->num; i++) {
752 verify_ctdb_node_and_flags(&p1->node[i], &p2->node[i]);
756 void fill_ctdb_script(TALLOC_CTX *mem_ctx, struct ctdb_script *p)
758 fill_buffer(p, sizeof(struct ctdb_script));
761 void verify_ctdb_script(struct ctdb_script *p1, struct ctdb_script *p2)
763 verify_buffer(p1, p2, sizeof(struct ctdb_script));
766 void fill_ctdb_script_list(TALLOC_CTX *mem_ctx, struct ctdb_script_list *p)
770 p->num_scripts = rand_int(32);
771 if (p->num_scripts > 0) {
772 p->script = talloc_array(mem_ctx, struct ctdb_script,
774 assert(p->script != NULL);
775 for (i=0; i<p->num_scripts; i++) {
776 fill_ctdb_script(mem_ctx, &p->script[i]);
783 void verify_ctdb_script_list(struct ctdb_script_list *p1,
784 struct ctdb_script_list *p2)
788 assert(p1->num_scripts == p2->num_scripts);
789 for (i=0; i<p1->num_scripts; i++) {
790 verify_ctdb_script(&p1->script[i], &p2->script[i]);
794 void fill_ctdb_ban_state(TALLOC_CTX *mem_ctx, struct ctdb_ban_state *p)
800 void verify_ctdb_ban_state(struct ctdb_ban_state *p1,
801 struct ctdb_ban_state *p2)
803 assert(p1->pnn == p2->pnn);
804 assert(p1->time == p2->time);
807 void fill_ctdb_notify_data(TALLOC_CTX *mem_ctx, struct ctdb_notify_data *p)
810 fill_tdb_data(mem_ctx, &p->data);
813 void verify_ctdb_notify_data(struct ctdb_notify_data *p1,
814 struct ctdb_notify_data *p2)
816 assert(p1->srvid == p2->srvid);
817 verify_tdb_data(&p1->data, &p2->data);
820 void fill_ctdb_iface(TALLOC_CTX *mem_ctx, struct ctdb_iface *p)
822 fill_buffer(p, sizeof(struct ctdb_iface));
825 void verify_ctdb_iface(struct ctdb_iface *p1, struct ctdb_iface *p2)
827 verify_buffer(p1, p2, sizeof(struct ctdb_iface));
830 void fill_ctdb_iface_list(TALLOC_CTX *mem_ctx, struct ctdb_iface_list *p)
834 p->num = rand_int(32);
836 p->iface = talloc_array(mem_ctx, struct ctdb_iface, p->num);
837 assert(p->iface != NULL);
838 for (i=0; i<p->num; i++) {
839 fill_ctdb_iface(mem_ctx, &p->iface[i]);
846 void verify_ctdb_iface_list(struct ctdb_iface_list *p1,
847 struct ctdb_iface_list *p2)
851 assert(p1->num == p2->num);
852 for (i=0; i<p1->num; i++) {
853 verify_ctdb_iface(&p1->iface[i], &p2->iface[i]);
857 void fill_ctdb_public_ip_info(TALLOC_CTX *mem_ctx,
858 struct ctdb_public_ip_info *p)
860 fill_ctdb_public_ip(mem_ctx, &p->ip);
861 p->active_idx = rand_int(32) + 1;
862 p->ifaces = talloc(mem_ctx, struct ctdb_iface_list);
863 assert(p->ifaces != NULL);
864 fill_ctdb_iface_list(mem_ctx, p->ifaces);
867 void verify_ctdb_public_ip_info(struct ctdb_public_ip_info *p1,
868 struct ctdb_public_ip_info *p2)
870 verify_ctdb_public_ip(&p1->ip, &p2->ip);
871 assert(p1->active_idx == p2->active_idx);
872 verify_ctdb_iface_list(p1->ifaces, p2->ifaces);
875 void fill_ctdb_statistics_list(TALLOC_CTX *mem_ctx,
876 struct ctdb_statistics_list *p)
880 p->num = rand_int(10);
882 p->stats = talloc_array(mem_ctx, struct ctdb_statistics,
884 assert(p->stats != NULL);
886 for (i=0; i<p->num; i++) {
887 fill_ctdb_statistics(mem_ctx, &p->stats[i]);
894 void verify_ctdb_statistics_list(struct ctdb_statistics_list *p1,
895 struct ctdb_statistics_list *p2)
899 assert(p1->num == p2->num);
900 for (i=0; i<p1->num; i++) {
901 verify_ctdb_statistics(&p1->stats[i], &p2->stats[i]);
905 void fill_ctdb_key_data(TALLOC_CTX *mem_ctx, struct ctdb_key_data *p)
908 fill_ctdb_ltdb_header(mem_ctx, &p->header);
909 fill_tdb_data_nonnull(mem_ctx, &p->key);
912 void verify_ctdb_key_data(struct ctdb_key_data *p1, struct ctdb_key_data *p2)
914 assert(p1->db_id == p2->db_id);
915 verify_ctdb_ltdb_header(&p1->header, &p2->header);
916 verify_tdb_data(&p1->key, &p2->key);
919 void fill_ctdb_db_statistics(TALLOC_CTX *mem_ctx,
920 struct ctdb_db_statistics *p)
924 fill_buffer(p, offsetof(struct ctdb_db_statistics, num_hot_keys));
925 p->num_hot_keys = 10;
926 for (i=0; i<p->num_hot_keys; i++) {
927 p->hot_keys[i].count = rand32();
928 fill_tdb_data(mem_ctx, &p->hot_keys[i].key);
932 void verify_ctdb_db_statistics(struct ctdb_db_statistics *p1,
933 struct ctdb_db_statistics *p2)
937 verify_buffer(p1, p2, offsetof(struct ctdb_db_statistics,
939 assert(p1->num_hot_keys == p2->num_hot_keys);
940 for (i=0; i<p1->num_hot_keys; i++) {
941 assert(p1->hot_keys[i].count == p2->hot_keys[i].count);
942 verify_tdb_data(&p1->hot_keys[i].key, &p2->hot_keys[i].key);
946 void fill_ctdb_election_message(TALLOC_CTX *mem_ctx,
947 struct ctdb_election_message *p)
949 p->num_connected = rand_int(32);
950 fill_buffer(&p->priority_time, sizeof(struct timeval));
951 p->pnn = rand_int(32);
952 p->node_flags = rand32();
955 void verify_ctdb_election_message(struct ctdb_election_message *p1,
956 struct ctdb_election_message *p2)
958 assert(p1->num_connected == p2->num_connected);
959 verify_buffer(p1, p2, sizeof(struct timeval));
960 assert(p1->pnn == p2->pnn);
961 assert(p1->node_flags == p2->node_flags);
964 void fill_ctdb_srvid_message(TALLOC_CTX *mem_ctx,
965 struct ctdb_srvid_message *p)
967 p->pnn = rand_int(32);
971 void verify_ctdb_srvid_message(struct ctdb_srvid_message *p1,
972 struct ctdb_srvid_message *p2)
974 assert(p1->pnn == p2->pnn);
975 assert(p1->srvid == p2->srvid);
978 void fill_ctdb_disable_message(TALLOC_CTX *mem_ctx,
979 struct ctdb_disable_message *p)
981 p->pnn = rand_int(32);
983 p->timeout = rand32();
986 void verify_ctdb_disable_message(struct ctdb_disable_message *p1,
987 struct ctdb_disable_message *p2)
989 assert(p1->pnn == p2->pnn);
990 assert(p1->srvid == p2->srvid);
991 assert(p1->timeout == p2->timeout);
994 void fill_ctdb_server_id(TALLOC_CTX *mem_ctx, struct ctdb_server_id *p)
997 p->task_id = rand32();
998 p->vnn = rand_int(32);
999 p->unique_id = rand64();
1002 void verify_ctdb_server_id(struct ctdb_server_id *p1,
1003 struct ctdb_server_id *p2)
1005 assert(p1->pid == p2->pid);
1006 assert(p1->task_id == p2->task_id);
1007 assert(p1->vnn == p2->vnn);
1008 assert(p1->unique_id == p2->unique_id);
1011 void fill_ctdb_g_lock(TALLOC_CTX *mem_ctx, struct ctdb_g_lock *p)
1013 p->type = rand_int(2);
1014 fill_ctdb_server_id(mem_ctx, &p->sid);
1017 void verify_ctdb_g_lock(struct ctdb_g_lock *p1, struct ctdb_g_lock *p2)
1019 assert(p1->type == p2->type);
1020 verify_ctdb_server_id(&p1->sid, &p2->sid);
1023 void fill_ctdb_g_lock_list(TALLOC_CTX *mem_ctx, struct ctdb_g_lock_list *p)
1027 p->num = rand_int(20) + 1;
1028 p->lock = talloc_array(mem_ctx, struct ctdb_g_lock, p->num);
1029 assert(p->lock != NULL);
1030 for (i=0; i<p->num; i++) {
1031 fill_ctdb_g_lock(mem_ctx, &p->lock[i]);
1035 void verify_ctdb_g_lock_list(struct ctdb_g_lock_list *p1,
1036 struct ctdb_g_lock_list *p2)
1040 assert(p1->num == p2->num);
1041 for (i=0; i<p1->num; i++) {
1042 verify_ctdb_g_lock(&p1->lock[i], &p2->lock[i]);