src/test/test-unaligned.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright 2014 Tom Gundersen
   4 ***/
   5
   6 #include "sparse-endian.h"
   7 #include "unaligned.h"
   8 #include "util.h"
   9
  10 static uint8_t data[] = {
  11         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  12         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  13 };
  14
  15 static void test_be(void) {
  16         uint8_t scratch[16];
  17
  18         assert_se(unaligned_read_be16(&data[0]) == 0x0001);
  19         assert_se(unaligned_read_be16(&data[1]) == 0x0102);
  20
  21         assert_se(unaligned_read_be32(&data[0]) == 0x00010203);
  22         assert_se(unaligned_read_be32(&data[1]) == 0x01020304);
  23         assert_se(unaligned_read_be32(&data[2]) == 0x02030405);
  24         assert_se(unaligned_read_be32(&data[3]) == 0x03040506);
  25
  26         assert_se(unaligned_read_be64(&data[0]) == 0x0001020304050607);
  27         assert_se(unaligned_read_be64(&data[1]) == 0x0102030405060708);
  28         assert_se(unaligned_read_be64(&data[2]) == 0x0203040506070809);
  29         assert_se(unaligned_read_be64(&data[3]) == 0x030405060708090a);
  30         assert_se(unaligned_read_be64(&data[4]) == 0x0405060708090a0b);
  31         assert_se(unaligned_read_be64(&data[5]) == 0x05060708090a0b0c);
  32         assert_se(unaligned_read_be64(&data[6]) == 0x060708090a0b0c0d);
  33         assert_se(unaligned_read_be64(&data[7]) == 0x0708090a0b0c0d0e);
  34
  35         zero(scratch);
  36         unaligned_write_be16(&scratch[0], 0x0001);
  37         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint16_t)) == 0);
  38         zero(scratch);
  39         unaligned_write_be16(&scratch[1], 0x0102);
  40         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint16_t)) == 0);
  41
  42         zero(scratch);
  43         unaligned_write_be32(&scratch[0], 0x00010203);
  44         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint32_t)) == 0);
  45         zero(scratch);
  46         unaligned_write_be32(&scratch[1], 0x01020304);
  47         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint32_t)) == 0);
  48         zero(scratch);
  49         unaligned_write_be32(&scratch[2], 0x02030405);
  50         assert_se(memcmp(&scratch[2], &data[2], sizeof(uint32_t)) == 0);
  51         zero(scratch);
  52         unaligned_write_be32(&scratch[3], 0x03040506);
  53         assert_se(memcmp(&scratch[3], &data[3], sizeof(uint32_t)) == 0);
  54
  55         zero(scratch);
  56         unaligned_write_be64(&scratch[0], 0x0001020304050607);
  57         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint64_t)) == 0);
  58         zero(scratch);
  59         unaligned_write_be64(&scratch[1], 0x0102030405060708);
  60         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint64_t)) == 0);
  61         zero(scratch);
  62         unaligned_write_be64(&scratch[2], 0x0203040506070809);
  63         assert_se(memcmp(&scratch[2], &data[2], sizeof(uint64_t)) == 0);
  64         zero(scratch);
  65         unaligned_write_be64(&scratch[3], 0x030405060708090a);
  66         assert_se(memcmp(&scratch[3], &data[3], sizeof(uint64_t)) == 0);
  67         zero(scratch);
  68         unaligned_write_be64(&scratch[4], 0x0405060708090a0b);
  69         assert_se(memcmp(&scratch[4], &data[4], sizeof(uint64_t)) == 0);
  70         zero(scratch);
  71         unaligned_write_be64(&scratch[5], 0x05060708090a0b0c);
  72         assert_se(memcmp(&scratch[5], &data[5], sizeof(uint64_t)) == 0);
  73         zero(scratch);
  74         unaligned_write_be64(&scratch[6], 0x060708090a0b0c0d);
  75         assert_se(memcmp(&scratch[6], &data[6], sizeof(uint64_t)) == 0);
  76         zero(scratch);
  77         unaligned_write_be64(&scratch[7], 0x0708090a0b0c0d0e);
  78         assert_se(memcmp(&scratch[7], &data[7], sizeof(uint64_t)) == 0);
  79 }
  80
  81 static void test_le(void) {
  82         uint8_t scratch[16];
  83
  84         assert_se(unaligned_read_le16(&data[0]) == 0x0100);
  85         assert_se(unaligned_read_le16(&data[1]) == 0x0201);
  86
  87         assert_se(unaligned_read_le32(&data[0]) == 0x03020100);
  88         assert_se(unaligned_read_le32(&data[1]) == 0x04030201);
  89         assert_se(unaligned_read_le32(&data[2]) == 0x05040302);
  90         assert_se(unaligned_read_le32(&data[3]) == 0x06050403);
  91
  92         assert_se(unaligned_read_le64(&data[0]) == 0x0706050403020100);
  93         assert_se(unaligned_read_le64(&data[1]) == 0x0807060504030201);
  94         assert_se(unaligned_read_le64(&data[2]) == 0x0908070605040302);
  95         assert_se(unaligned_read_le64(&data[3]) == 0x0a09080706050403);
  96         assert_se(unaligned_read_le64(&data[4]) == 0x0b0a090807060504);
  97         assert_se(unaligned_read_le64(&data[5]) == 0x0c0b0a0908070605);
  98         assert_se(unaligned_read_le64(&data[6]) == 0x0d0c0b0a09080706);
  99         assert_se(unaligned_read_le64(&data[7]) == 0x0e0d0c0b0a090807);
 100
 101         zero(scratch);
 102         unaligned_write_le16(&scratch[0], 0x0100);
 103         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint16_t)) == 0);
 104         zero(scratch);
 105         unaligned_write_le16(&scratch[1], 0x0201);
 106         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint16_t)) == 0);
 107
 108         zero(scratch);
 109         unaligned_write_le32(&scratch[0], 0x03020100);
 110
 111         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint32_t)) == 0);
 112         zero(scratch);
 113         unaligned_write_le32(&scratch[1], 0x04030201);
 114         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint32_t)) == 0);
 115         zero(scratch);
 116         unaligned_write_le32(&scratch[2], 0x05040302);
 117         assert_se(memcmp(&scratch[2], &data[2], sizeof(uint32_t)) == 0);
 118         zero(scratch);
 119         unaligned_write_le32(&scratch[3], 0x06050403);
 120         assert_se(memcmp(&scratch[3], &data[3], sizeof(uint32_t)) == 0);
 121
 122         zero(scratch);
 123         unaligned_write_le64(&scratch[0], 0x0706050403020100);
 124         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint64_t)) == 0);
 125         zero(scratch);
 126         unaligned_write_le64(&scratch[1], 0x0807060504030201);
 127         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint64_t)) == 0);
 128         zero(scratch);
 129         unaligned_write_le64(&scratch[2], 0x0908070605040302);
 130         assert_se(memcmp(&scratch[2], &data[2], sizeof(uint64_t)) == 0);
 131         zero(scratch);
 132         unaligned_write_le64(&scratch[3], 0x0a09080706050403);
 133         assert_se(memcmp(&scratch[3], &data[3], sizeof(uint64_t)) == 0);
 134         zero(scratch);
 135         unaligned_write_le64(&scratch[4], 0x0B0A090807060504);
 136         assert_se(memcmp(&scratch[4], &data[4], sizeof(uint64_t)) == 0);
 137         zero(scratch);
 138         unaligned_write_le64(&scratch[5], 0x0c0b0a0908070605);
 139         assert_se(memcmp(&scratch[5], &data[5], sizeof(uint64_t)) == 0);
 140         zero(scratch);
 141         unaligned_write_le64(&scratch[6], 0x0d0c0b0a09080706);
 142         assert_se(memcmp(&scratch[6], &data[6], sizeof(uint64_t)) == 0);
 143         zero(scratch);
 144         unaligned_write_le64(&scratch[7], 0x0e0d0c0b0a090807);
 145         assert_se(memcmp(&scratch[7], &data[7], sizeof(uint64_t)) == 0);
 146 }
 147
 148 static void test_ne(void) {
 149         uint16_t x = 4711;
 150         uint32_t y = 123456;
 151         uint64_t z = 9876543210;
 152
 153         /* Note that we don't bother actually testing alignment issues in this function, after all the _ne() functions
 154          * are just aliases for the _le() or _be() implementations, which we test extensively above. Hence, in this
 155          * function, just ensure that they map to the right version on the local architecture. */
 156
 157         assert_se(unaligned_read_ne16(&x) == 4711);
 158         assert_se(unaligned_read_ne32(&y) == 123456);
 159         assert_se(unaligned_read_ne64(&z) == 9876543210);
 160
 161         unaligned_write_ne16(&x, 1);
 162         unaligned_write_ne32(&y, 2);
 163         unaligned_write_ne64(&z, 3);
 164
 165         assert_se(x == 1);
 166         assert_se(y == 2);
 167         assert_se(z == 3);
 168 }
 169
 170 int main(int argc, const char *argv[]) {
 171         test_be();
 172         test_le();
 173         test_ne();
 174         return 0;
 175 }