ctdb/tests/src/protocol_common_basic.c

   1 /*
   2    protocol tests - common functions - basic types
   3
   4    Copyright (C) Amitay Isaacs  2015-2017
   5
   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.
  10
  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.
  15
  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/>.
  18 */
  19
  20 #include "replace.h"
  21
  22 #include <assert.h>
  23
  24 #include "tests/src/protocol_common_basic.h"
  25
  26 uint8_t BUFFER[1024*1024];
  27
  28 /*
  29  * Functions to generation random data
  30  */
  31
  32 int rand_int(int max)
  33 {
  34         return random() % max;
  35 }
  36
  37 uint8_t rand8(void)
  38 {
  39         uint8_t val = rand_int(256) & 0xff;
  40         return val;
  41 }
  42
  43 uint16_t rand16(void)
  44 {
  45         uint16_t val = rand_int(0xffff) & 0xffff;
  46         return val;
  47 }
  48
  49 int32_t rand32i(void)
  50 {
  51         return INT_MIN + random();
  52 }
  53
  54 uint32_t rand32(void)
  55 {
  56         return random();
  57 }
  58
  59 uint64_t rand64(void)
  60 {
  61         uint64_t t = random();
  62         t = (t << 32) | random();
  63         return t;
  64 }
  65
  66 double rand_double(void)
  67 {
  68         return 1.0 / rand64();
  69 }
  70
  71 void fill_buffer(void *p, size_t len)
  72 {
  73         size_t i;
  74         uint8_t *ptr = p;
  75
  76         for (i=0; i<len; i++) {
  77                 ptr[i] = rand8();
  78         }
  79 }
  80
  81 void verify_buffer(void *p1, void *p2, size_t len)
  82 {
  83         if (len > 0) {
  84                 assert(memcmp(p1, p2, len) == 0);
  85         }
  86 }
  87
  88 void fill_string(char *p, size_t len)
  89 {
  90         size_t i;
  91
  92         for (i=0; i<len-1; i++) {
  93                 p[i] = 'A' + rand_int(26);
  94         }
  95         p[len-1] = '\0';
  96 }
  97
  98 void verify_string(const char *p1, const char *p2)
  99 {
 100         assert(strlen(p1) == strlen(p2));
 101         assert(strcmp(p1, p2) == 0);
 102 }
 103
 104 void fill_ctdb_uint8(uint8_t *p)
 105 {
 106         *p = rand8();
 107 }
 108
 109 void verify_ctdb_uint8(uint8_t *p1, uint8_t *p2)
 110 {
 111         assert(*p1 == *p2);
 112 }
 113
 114 void fill_ctdb_uint16(uint16_t *p)
 115 {
 116         *p = rand16();
 117 }
 118
 119 void verify_ctdb_uint16(uint16_t *p1, uint16_t *p2)
 120 {
 121         assert(*p1 == *p2);
 122 }
 123
 124 void fill_ctdb_int32(int32_t *p)
 125 {
 126         *p = rand32i();
 127 }
 128
 129 void verify_ctdb_int32(int32_t *p1, int32_t *p2)
 130 {
 131         assert(*p1 == *p2);
 132 }
 133
 134 void fill_ctdb_uint32(uint32_t *p)
 135 {
 136         *p = rand32();
 137 }
 138
 139 void verify_ctdb_uint32(uint32_t *p1, uint32_t *p2)
 140 {
 141         assert(*p1 == *p2);
 142 }
 143
 144 void fill_ctdb_uint64(uint64_t *p)
 145 {
 146         *p = rand64();
 147 }
 148
 149 void verify_ctdb_uint64(uint64_t *p1, uint64_t *p2)
 150 {
 151         assert(*p1 == *p2);
 152 }
 153
 154 void fill_ctdb_double(double *p)
 155 {
 156         *p = rand_double();
 157 }
 158
 159 void verify_ctdb_double(double *p1, double *p2)
 160 {
 161         assert(*p1 == *p2);
 162 }
 163
 164 void fill_ctdb_bool(bool *p)
 165 {
 166         if (rand_int(2) == 0) {
 167                 *p = true;
 168         } else {
 169                 *p = false;
 170         }
 171 }
 172
 173 void verify_ctdb_bool(bool *p1, bool *p2)
 174 {
 175         assert(*p1 == *p2);
 176 }
 177
 178 void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **p)
 179 {
 180         char *str;
 181         int len;
 182
 183         len = rand_int(1024) + 2;
 184         str = talloc_size(mem_ctx, len+1);
 185         assert(str != NULL);
 186
 187         fill_string(str, len);
 188         *p = str;
 189 }
 190
 191 void verify_ctdb_string(const char **p1, const char **p2)
 192 {
 193         if (*p1 == NULL || *p2 == NULL) {
 194                 assert(*p1 == *p2);
 195         } else {
 196                 verify_string(*p1, *p2);
 197         }
 198 }
 199
 200 void fill_ctdb_stringn(TALLOC_CTX *mem_ctx, const char **p)
 201 {
 202         fill_ctdb_string(mem_ctx, p);
 203 }
 204
 205 void verify_ctdb_stringn(const char **p1, const char **p2)
 206 {
 207         verify_ctdb_string(p1, p2);
 208 }
 209
 210 void fill_ctdb_pid(pid_t *p)
 211 {
 212         *p = rand32();
 213 }
 214
 215 void verify_ctdb_pid(pid_t *p1, pid_t *p2)
 216 {
 217         assert(*p1 == *p2);
 218 }
 219
 220 void fill_ctdb_timeval(struct timeval *p)
 221 {
 222         p->tv_sec = rand32();
 223         p->tv_usec = rand_int(1000000);
 224 }
 225
 226 void verify_ctdb_timeval(struct timeval *p1, struct timeval *p2)
 227 {
 228         assert(p1->tv_sec == p2->tv_sec);
 229         assert(p1->tv_usec == p2->tv_usec);
 230 }
 231
 232 static unsigned int seed;
 233 static char protocol_test_iterate_buf[1024];
 234
 235 static void protocol_test_iterate_abort_handler(int sig)
 236 {
 237        struct sigaction act = {
 238                .sa_handler = SIG_DFL,
 239        };
 240
 241        fprintf(stderr, "Failed with seed: %d\n", seed);
 242        if (protocol_test_iterate_buf[0] != '\0') {
 243                fprintf(stderr, " tag: %s\n", protocol_test_iterate_buf);
 244        }
 245        sigaction(SIGABRT, &act, NULL);
 246        abort();
 247 }
 248
 249 void protocol_test_iterate_tag(const char *fmt, ...)
 250 {
 251         va_list ap;
 252         int count;
 253
 254         va_start(ap,fmt);
 255         count = vsnprintf(protocol_test_iterate_buf,
 256                           sizeof(protocol_test_iterate_buf),
 257                           fmt,
 258                           ap);
 259         va_end(ap);
 260
 261         assert(count >= 0);
 262         protocol_test_iterate_buf[sizeof(protocol_test_iterate_buf) - 1] = '\0';
 263 }
 264
 265 void protocol_test_iterate(int argc,
 266                            const char *argv[],
 267                            void (*test_func)(void))
 268 {
 269        struct sigaction act = {
 270                .sa_handler = protocol_test_iterate_abort_handler,
 271        };
 272        unsigned int min, max;
 273
 274        if (argc == 2 || argc == 3) {
 275                min = atoi(argv[1]);
 276
 277                if (argc == 3) {
 278                        max = atoi(argv[2]);
 279                        if (min >= max) {
 280                                fprintf(stderr,
 281                                        "%s: min must be less than max\n",
 282                                        argv[0]);
 283                                exit(1);
 284                        }
 285
 286                } else {
 287                        max = min;
 288                }
 289        } else {
 290                fprintf(stderr, "usage: %s min [max]\n", argv[0]);
 291                exit(1);
 292        }
 293
 294        sigaction(SIGABRT, &act, NULL);
 295
 296        for (seed = min; seed <= max ; seed++) {
 297                srandom(seed);
 298
 299                test_func();
 300        }
 301 }