lib/util/tests/test_byteorder.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  *
   4  * Copyright (C) 2018-2019 Andreas Schneider <asn@samba.org>
   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 <stdarg.h>
  21 #include <stddef.h>
  22 #include <stdint.h>
  23 #include <setjmp.h>
  24 #include <cmocka.h>
  25
  26 #include "lib/replace/replace.h"
  27 #include "lib/util/byteorder.h"
  28
  29 static void torture_pull_le_u8(void **state)
  30 {
  31         uint8_t data[2] = {0};
  32         uint8_t result;
  33
  34         (void)state;
  35
  36         result = CVAL(data, 0);
  37         assert_int_equal(result, 0);
  38
  39         data[0] = 0x2a;
  40         result = CVAL(data, 0);
  41         assert_int_equal(result, 42);
  42
  43
  44         data[0] = 0xf;
  45         result = CVAL(data, 0);
  46         assert_int_equal(result, 0xf);
  47
  48         data[0] = 0xff;
  49         result = CVAL(data, 0);
  50         assert_int_equal(result, 0xff);
  51
  52         data[1] = 0x2a;
  53         result = CVAL(data, 1);
  54         assert_int_equal(result, 42);
  55 }
  56
  57 static void torture_pull_le_u16(void **state)
  58 {
  59         uint8_t data[2] = {0, 0};
  60         uint16_t result;
  61
  62         (void)state;
  63
  64         result = SVAL(data, 0);
  65         assert_int_equal(result, 0);
  66
  67         data[0] = 0x2a;
  68         data[1] = 0x00;
  69         result = SVAL(data, 0);
  70         assert_int_equal(result, 42);
  71
  72         data[0] = 0xff;
  73         data[1] = 0x00;
  74         result = SVAL(data, 0);
  75         assert_int_equal(result, 0x00ff);
  76
  77         data[0] = 0x00;
  78         data[1] = 0xff;
  79         result = SVAL(data, 0);
  80         assert_int_equal(result, 0xff00);
  81
  82         data[0] = 0xff;
  83         data[1] = 0xff;
  84         result = SVAL(data, 0);
  85         assert_int_equal(result, 0xffff);
  86 }
  87
  88 static void torture_pull_le_u32(void **state)
  89 {
  90         uint8_t data[4] = {0, 0, 0, 0};
  91         uint32_t result;
  92
  93         (void)state;
  94
  95         result = IVAL(data, 0);
  96         assert_int_equal(result, 0);
  97
  98         data[0] = 0x2a;
  99         data[1] = 0x00;
 100         data[2] = 0x00;
 101         data[3] = 0x00;
 102         result = IVAL(data, 0);
 103         assert_int_equal(result, 42);
 104
 105         data[0] = 0xff;
 106         data[1] = 0x00;
 107         data[2] = 0x00;
 108         data[3] = 0x00;
 109         result = IVAL(data, 0);
 110         assert_int_equal(result, 0x00ff);
 111
 112         data[0] = 0x00;
 113         data[1] = 0xff;
 114         data[2] = 0x00;
 115         data[3] = 0x00;
 116         result = IVAL(data, 0);
 117         assert_int_equal(result, 0xff00);
 118
 119         data[0] = 0x00;
 120         data[1] = 0x00;
 121         data[2] = 0xff;
 122         data[3] = 0x00;
 123         result = IVAL(data, 0);
 124         assert_int_equal(result, 0xff0000);
 125
 126         data[0] = 0x00;
 127         data[1] = 0x00;
 128         data[2] = 0x00;
 129         data[3] = 0xff;
 130         result = IVAL(data, 0);
 131         assert_int_equal(result, 0xff000000);
 132
 133         data[0] = 0xff;
 134         data[1] = 0xff;
 135         data[2] = 0xff;
 136         data[3] = 0xff;
 137         result = IVAL(data, 0);
 138         assert_int_equal(result, 0xffffffff);
 139 }
 140
 141 static void torture_push_le_u8(void **state)
 142 {
 143         uint8_t data[4] = {0, 0, 0, 0};
 144         uint8_t data2[4] = {42, 42, 42, 42};
 145
 146         (void)state;
 147
 148         SCVAL(data, 0, 42);
 149         SCVAL(data, 1, 42);
 150         SCVAL(data, 2, 42);
 151         SCVAL(data, 3, 42);
 152         assert_memory_equal(data, data2, sizeof(data));
 153 }
 154
 155 static void torture_push_le_u16(void **state)
 156 {
 157         uint8_t data[4] = {0, 0, 0, 0};
 158         uint8_t data2[4] = {0xa6, 0x7f, 0x2a, 0x00};
 159         uint16_t result;
 160
 161         (void)state;
 162
 163         SSVALX(data, 0, 32678);
 164         SSVALX(data, 2, 42);
 165         assert_memory_equal(data, data2, sizeof(data));
 166
 167         result = SVAL(data, 2);
 168         assert_int_equal(result, 42);
 169
 170         result = SVAL(data, 0);
 171         assert_int_equal(result, 32678);
 172 }
 173
 174 static void torture_push_le_u32(void **state)
 175 {
 176         uint8_t data[8] = {0};
 177         uint8_t data2[8] = {0xa6, 0x7f, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00};
 178         uint32_t result;
 179
 180         (void)state;
 181
 182         SIVALX(data, 0, 32678);
 183         SIVALX(data, 4, 42);
 184         assert_memory_equal(data, data2, sizeof(data));
 185
 186         result = IVAL(data, 4);
 187         assert_int_equal(result, 42);
 188
 189         result = IVAL(data, 0);
 190         assert_int_equal(result, 32678);
 191
 192         SIVALX(data, 0, 0xfffefffe);
 193         result = IVAL(data, 0);
 194         assert_int_equal(result, 0xfffefffe);
 195 }
 196
 197 static void torture_push_le_u64(void **state)
 198 {
 199         uint8_t data[16] = {0};
 200         uint64_t result;
 201
 202         (void)state;
 203
 204         SBVAL(data, 0, 32678);
 205
 206         result = BVAL(data, 0);
 207         assert_int_equal(result, 32678);
 208
 209         SBVAL(data, 0, 0xfffefffefffefffeUL);
 210
 211         result = BVAL(data, 0);
 212         assert_int_equal(result, 0xfffefffefffefffeUL);
 213 }
 214
 215 /****************** BIG ENDIAN ********************/
 216
 217 static void torture_pull_be_u8(void **state)
 218 {
 219         uint8_t data[2] = {0};
 220         uint8_t result;
 221
 222         (void)state;
 223
 224         result = CVAL(data, 0);
 225         assert_int_equal(result, 0);
 226
 227         data[0] = 0x2a;
 228         result = CVAL(data, 0);
 229         assert_int_equal(result, 42);
 230
 231
 232         data[0] = 0xf;
 233         result = CVAL(data, 0);
 234         assert_int_equal(result, 0xf);
 235
 236         data[0] = 0xff;
 237         result = CVAL(data, 0);
 238         assert_int_equal(result, 0xff);
 239
 240         data[1] = 0x2a;
 241         result = CVAL(data, 1);
 242         assert_int_equal(result, 42);
 243 }
 244
 245 static void torture_pull_be_u16(void **state)
 246 {
 247         uint8_t data[2] = {0, 0};
 248         uint16_t result;
 249
 250         (void)state;
 251
 252         result = RSVAL(data, 0);
 253         assert_int_equal(result, 0);
 254
 255         data[0] = 0x00;
 256         data[1] = 0x2a;
 257         result = RSVAL(data, 0);
 258         assert_int_equal(result, 42);
 259
 260         data[0] = 0x00;
 261         data[1] = 0xff;
 262         result = RSVAL(data, 0);
 263         assert_int_equal(result, 0x00ff);
 264
 265         data[0] = 0xff;
 266         data[1] = 0x00;
 267         result = RSVAL(data, 0);
 268         assert_int_equal(result, 0xff00);
 269
 270         data[0] = 0xff;
 271         data[1] = 0xff;
 272         result = RSVAL(data, 0);
 273         assert_int_equal(result, 0xffff);
 274 }
 275
 276 static void torture_pull_be_u32(void **state)
 277 {
 278         uint8_t data[4] = {0, 0, 0, 0};
 279         uint32_t result;
 280
 281         (void)state;
 282
 283         result = RIVAL(data, 0);
 284         assert_int_equal(result, 0);
 285
 286         data[0] = 0x00;
 287         data[1] = 0x00;
 288         data[2] = 0x00;
 289         data[3] = 0x2a;
 290         result = RIVAL(data, 0);
 291         assert_int_equal(result, 42);
 292
 293         data[0] = 0x00;
 294         data[1] = 0x00;
 295         data[2] = 0x00;
 296         data[3] = 0xff;
 297         result = RIVAL(data, 0);
 298         assert_int_equal(result, 0x00ff);
 299
 300         data[0] = 0x00;
 301         data[1] = 0x00;
 302         data[2] = 0xff;
 303         data[3] = 0x00;
 304         result = RIVAL(data, 0);
 305         assert_int_equal(result, 0xff00);
 306
 307         data[0] = 0x00;
 308         data[1] = 0xff;
 309         data[2] = 0x00;
 310         data[3] = 0x00;
 311         result = RIVAL(data, 0);
 312         assert_int_equal(result, 0xff0000);
 313
 314         data[0] = 0xff;
 315         data[1] = 0x00;
 316         data[2] = 0x00;
 317         data[3] = 0x00;
 318         result = RIVAL(data, 0);
 319         assert_int_equal(result, 0xff000000);
 320
 321         data[0] = 0xff;
 322         data[1] = 0xff;
 323         data[2] = 0xff;
 324         data[3] = 0xff;
 325         result = RIVAL(data, 0);
 326         assert_int_equal(result, 0xffffffff);
 327 }
 328
 329 static void torture_push_be_u8(void **state)
 330 {
 331         uint8_t data[4] = {0, 0, 0, 0};
 332         uint8_t data2[4] = {42, 42, 42, 42};
 333
 334         (void)state;
 335
 336         SCVAL(data, 0, 42);
 337         SCVAL(data, 1, 42);
 338         SCVAL(data, 2, 42);
 339         SCVAL(data, 3, 42);
 340         assert_memory_equal(data, data2, sizeof(data));
 341 }
 342
 343 static void torture_push_be_u16(void **state)
 344 {
 345         uint8_t data[4] = {0, 0, 0, 0};
 346         uint8_t data2[4] = {0x7f, 0xa6, 0x00, 0x2a};
 347         uint16_t result;
 348
 349         (void)state;
 350
 351         RSSVALS(data, 0, 32678);
 352         RSSVALS(data, 2, 42);
 353         assert_memory_equal(data, data2, sizeof(data));
 354
 355         result = RSVAL(data, 2);
 356         assert_int_equal(result, 42);
 357
 358         result = RSVAL(data, 0);
 359         assert_int_equal(result, 32678);
 360 }
 361
 362 static void torture_push_be_u32(void **state)
 363 {
 364         uint8_t data[8] = {0};
 365         uint8_t data2[8] = {0x00, 0x00, 0x7f, 0xa6, 0x00, 0x00, 0x00, 0x2a};
 366         uint32_t result;
 367
 368         (void)state;
 369
 370         RSIVALS(data, 0, 32678);
 371         RSIVALS(data, 4, 42);
 372         assert_memory_equal(data, data2, sizeof(data));
 373
 374         result = RIVAL(data, 4);
 375         assert_int_equal(result, 42);
 376
 377         result = RIVAL(data, 0);
 378         assert_int_equal(result, 32678);
 379
 380         RSIVALS(data, 0, 0xfffefffe);
 381         result = RIVAL(data, 0);
 382         assert_int_equal(result, 0xfffefffe);
 383 }
 384
 385 static void torture_push_be_u64(void **state)
 386 {
 387         uint8_t data[16] = {0};
 388         uint64_t result;
 389
 390         (void)state;
 391
 392         RSBVALS(data, 0, 32678);
 393
 394         result = RBVAL(data, 0);
 395         assert_int_equal(result, 32678);
 396
 397         SBVAL(data, 8, 0xfffefffe);
 398
 399         result = BVAL(data, 8);
 400         assert_int_equal(result, 0xfffefffe);
 401 }
 402
 403 int main(int argc, char *argv[])
 404 {
 405         int rc;
 406         const struct CMUnitTest tests[] = {
 407                 cmocka_unit_test(torture_pull_le_u8),
 408                 cmocka_unit_test(torture_pull_le_u16),
 409                 cmocka_unit_test(torture_pull_le_u32),
 410
 411                 cmocka_unit_test(torture_push_le_u8),
 412                 cmocka_unit_test(torture_push_le_u16),
 413                 cmocka_unit_test(torture_push_le_u32),
 414                 cmocka_unit_test(torture_push_le_u64),
 415
 416                 /* BIG ENDIAN */
 417                 cmocka_unit_test(torture_pull_be_u8),
 418                 cmocka_unit_test(torture_pull_be_u16),
 419                 cmocka_unit_test(torture_pull_be_u32),
 420
 421                 cmocka_unit_test(torture_push_be_u8),
 422                 cmocka_unit_test(torture_push_be_u16),
 423                 cmocka_unit_test(torture_push_be_u32),
 424                 cmocka_unit_test(torture_push_be_u64),
 425         };
 426
 427         if (argc == 2) {
 428                 cmocka_set_test_filter(argv[1]);
 429         }
 430         cmocka_set_message_output(CM_OUTPUT_SUBUNIT);
 431
 432         rc = cmocka_run_group_tests(tests, NULL, NULL);
 433
 434         return rc;
 435 }