]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-unaligned.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd
5 Copyright 2014 Tom Gundersen
8 #include "sparse-endian.h"
12 static uint8_t data
[] = {
13 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
14 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
17 static void test_be(void) {
20 assert_se(unaligned_read_be16(&data
[0]) == 0x0001);
21 assert_se(unaligned_read_be16(&data
[1]) == 0x0102);
23 assert_se(unaligned_read_be32(&data
[0]) == 0x00010203);
24 assert_se(unaligned_read_be32(&data
[1]) == 0x01020304);
25 assert_se(unaligned_read_be32(&data
[2]) == 0x02030405);
26 assert_se(unaligned_read_be32(&data
[3]) == 0x03040506);
28 assert_se(unaligned_read_be64(&data
[0]) == 0x0001020304050607);
29 assert_se(unaligned_read_be64(&data
[1]) == 0x0102030405060708);
30 assert_se(unaligned_read_be64(&data
[2]) == 0x0203040506070809);
31 assert_se(unaligned_read_be64(&data
[3]) == 0x030405060708090a);
32 assert_se(unaligned_read_be64(&data
[4]) == 0x0405060708090a0b);
33 assert_se(unaligned_read_be64(&data
[5]) == 0x05060708090a0b0c);
34 assert_se(unaligned_read_be64(&data
[6]) == 0x060708090a0b0c0d);
35 assert_se(unaligned_read_be64(&data
[7]) == 0x0708090a0b0c0d0e);
38 unaligned_write_be16(&scratch
[0], 0x0001);
39 assert_se(memcmp(&scratch
[0], &data
[0], sizeof(uint16_t)) == 0);
41 unaligned_write_be16(&scratch
[1], 0x0102);
42 assert_se(memcmp(&scratch
[1], &data
[1], sizeof(uint16_t)) == 0);
45 unaligned_write_be32(&scratch
[0], 0x00010203);
46 assert_se(memcmp(&scratch
[0], &data
[0], sizeof(uint32_t)) == 0);
48 unaligned_write_be32(&scratch
[1], 0x01020304);
49 assert_se(memcmp(&scratch
[1], &data
[1], sizeof(uint32_t)) == 0);
51 unaligned_write_be32(&scratch
[2], 0x02030405);
52 assert_se(memcmp(&scratch
[2], &data
[2], sizeof(uint32_t)) == 0);
54 unaligned_write_be32(&scratch
[3], 0x03040506);
55 assert_se(memcmp(&scratch
[3], &data
[3], sizeof(uint32_t)) == 0);
58 unaligned_write_be64(&scratch
[0], 0x0001020304050607);
59 assert_se(memcmp(&scratch
[0], &data
[0], sizeof(uint64_t)) == 0);
61 unaligned_write_be64(&scratch
[1], 0x0102030405060708);
62 assert_se(memcmp(&scratch
[1], &data
[1], sizeof(uint64_t)) == 0);
64 unaligned_write_be64(&scratch
[2], 0x0203040506070809);
65 assert_se(memcmp(&scratch
[2], &data
[2], sizeof(uint64_t)) == 0);
67 unaligned_write_be64(&scratch
[3], 0x030405060708090a);
68 assert_se(memcmp(&scratch
[3], &data
[3], sizeof(uint64_t)) == 0);
70 unaligned_write_be64(&scratch
[4], 0x0405060708090a0b);
71 assert_se(memcmp(&scratch
[4], &data
[4], sizeof(uint64_t)) == 0);
73 unaligned_write_be64(&scratch
[5], 0x05060708090a0b0c);
74 assert_se(memcmp(&scratch
[5], &data
[5], sizeof(uint64_t)) == 0);
76 unaligned_write_be64(&scratch
[6], 0x060708090a0b0c0d);
77 assert_se(memcmp(&scratch
[6], &data
[6], sizeof(uint64_t)) == 0);
79 unaligned_write_be64(&scratch
[7], 0x0708090a0b0c0d0e);
80 assert_se(memcmp(&scratch
[7], &data
[7], sizeof(uint64_t)) == 0);
83 static void test_le(void) {
86 assert_se(unaligned_read_le16(&data
[0]) == 0x0100);
87 assert_se(unaligned_read_le16(&data
[1]) == 0x0201);
89 assert_se(unaligned_read_le32(&data
[0]) == 0x03020100);
90 assert_se(unaligned_read_le32(&data
[1]) == 0x04030201);
91 assert_se(unaligned_read_le32(&data
[2]) == 0x05040302);
92 assert_se(unaligned_read_le32(&data
[3]) == 0x06050403);
94 assert_se(unaligned_read_le64(&data
[0]) == 0x0706050403020100);
95 assert_se(unaligned_read_le64(&data
[1]) == 0x0807060504030201);
96 assert_se(unaligned_read_le64(&data
[2]) == 0x0908070605040302);
97 assert_se(unaligned_read_le64(&data
[3]) == 0x0a09080706050403);
98 assert_se(unaligned_read_le64(&data
[4]) == 0x0b0a090807060504);
99 assert_se(unaligned_read_le64(&data
[5]) == 0x0c0b0a0908070605);
100 assert_se(unaligned_read_le64(&data
[6]) == 0x0d0c0b0a09080706);
101 assert_se(unaligned_read_le64(&data
[7]) == 0x0e0d0c0b0a090807);
104 unaligned_write_le16(&scratch
[0], 0x0100);
105 assert_se(memcmp(&scratch
[0], &data
[0], sizeof(uint16_t)) == 0);
107 unaligned_write_le16(&scratch
[1], 0x0201);
108 assert_se(memcmp(&scratch
[1], &data
[1], sizeof(uint16_t)) == 0);
111 unaligned_write_le32(&scratch
[0], 0x03020100);
113 assert_se(memcmp(&scratch
[0], &data
[0], sizeof(uint32_t)) == 0);
115 unaligned_write_le32(&scratch
[1], 0x04030201);
116 assert_se(memcmp(&scratch
[1], &data
[1], sizeof(uint32_t)) == 0);
118 unaligned_write_le32(&scratch
[2], 0x05040302);
119 assert_se(memcmp(&scratch
[2], &data
[2], sizeof(uint32_t)) == 0);
121 unaligned_write_le32(&scratch
[3], 0x06050403);
122 assert_se(memcmp(&scratch
[3], &data
[3], sizeof(uint32_t)) == 0);
125 unaligned_write_le64(&scratch
[0], 0x0706050403020100);
126 assert_se(memcmp(&scratch
[0], &data
[0], sizeof(uint64_t)) == 0);
128 unaligned_write_le64(&scratch
[1], 0x0807060504030201);
129 assert_se(memcmp(&scratch
[1], &data
[1], sizeof(uint64_t)) == 0);
131 unaligned_write_le64(&scratch
[2], 0x0908070605040302);
132 assert_se(memcmp(&scratch
[2], &data
[2], sizeof(uint64_t)) == 0);
134 unaligned_write_le64(&scratch
[3], 0x0a09080706050403);
135 assert_se(memcmp(&scratch
[3], &data
[3], sizeof(uint64_t)) == 0);
137 unaligned_write_le64(&scratch
[4], 0x0B0A090807060504);
138 assert_se(memcmp(&scratch
[4], &data
[4], sizeof(uint64_t)) == 0);
140 unaligned_write_le64(&scratch
[5], 0x0c0b0a0908070605);
141 assert_se(memcmp(&scratch
[5], &data
[5], sizeof(uint64_t)) == 0);
143 unaligned_write_le64(&scratch
[6], 0x0d0c0b0a09080706);
144 assert_se(memcmp(&scratch
[6], &data
[6], sizeof(uint64_t)) == 0);
146 unaligned_write_le64(&scratch
[7], 0x0e0d0c0b0a090807);
147 assert_se(memcmp(&scratch
[7], &data
[7], sizeof(uint64_t)) == 0);
150 static void test_ne(void) {
153 uint64_t z
= 9876543210;
155 /* Note that we don't bother actually testing alignment issues in this function, after all the _ne() functions
156 * are just aliases for the _le() or _be() implementations, which we test extensively above. Hence, in this
157 * function, just ensure that they map to the right version on the local architecture. */
159 assert_se(unaligned_read_ne16(&x
) == 4711);
160 assert_se(unaligned_read_ne32(&y
) == 123456);
161 assert_se(unaligned_read_ne64(&z
) == 9876543210);
163 unaligned_write_ne16(&x
, 1);
164 unaligned_write_ne32(&y
, 2);
165 unaligned_write_ne64(&z
, 3);
172 int main(int argc
, const char *argv
[]) {