Debian Codegraph @

libdrgn/tests/serialize.c.in

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include "test_util.h"
5 #include "../serialize.h"
6 #include "../util.h"
7
8 struct foo64 {
9 uint64_t big;
10 uint32_t medium;
11 uint16_t small;
12 uint8_t tiny;
13 uint8_t array[3];
14 // Add padding so size is consistent on all architectures.
15 uint8_t pad[6];
16 };
17
18 struct foo32 {
19 uint32_t big;
20 uint16_t medium;
21 uint8_t small;
22 uint8_t tiny;
23 uint8_t array[3];
24 // Add padding so size is consistent on all architectures.
25 uint8_t pad;
26 };
27
28 #define visit_foo_members(visit_scalar_member, visit_raw_member) do { \
29 visit_scalar_member(big); \
30 visit_scalar_member(medium); \
31 visit_scalar_member(small); \
32 visit_scalar_member(tiny); \
33 visit_raw_member(array); \
34 } while (0)
35
36 #suite serialize
37
38 #tcase deserialize_struct64
39
40 #test deserialize_struct64_64le
41 {
42 uint8_t buf[24] = {
43 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00,
44 0xa0, 0x86, 0x01, 0x00,
45 0x20, 0x03,
46 0x0a,
47 0x41, 0x42, 0x43,
48 };
49 struct foo64 foo;
50 deserialize_struct64(&foo, struct foo32, visit_foo_members, buf, true,
51 !HOST_LITTLE_ENDIAN);
52 ck_assert_uint_eq(foo.big, 5000000000);
53 ck_assert_uint_eq(foo.medium, 100000);
54 ck_assert_uint_eq(foo.small, 800);
55 ck_assert_uint_eq(foo.tiny, 10);
56 ck_assert_mem_eq(foo.array, "ABC", 3);
57 }
58
59 #test deserialize_struct64_64be
60 {
61 uint8_t buf[24] = {
62 0x00, 0x00, 0x00, 0x01, 0x2a, 0x05, 0xf2, 0x00,
63 0x00, 0x01, 0x86, 0xa0,
64 0x03, 0x20,
65 0x0a,
66 0x41, 0x42, 0x43,
67 };
68 struct foo64 foo;
69 deserialize_struct64(&foo, struct foo32, visit_foo_members, buf, true,
70 HOST_LITTLE_ENDIAN);
71 ck_assert_uint_eq(foo.big, 5000000000);
72 ck_assert_uint_eq(foo.medium, 100000);
73 ck_assert_uint_eq(foo.small, 800);
74 ck_assert_uint_eq(foo.tiny, 10);
75 ck_assert_mem_eq(foo.array, "ABC", 3);
76 }
77
78 #test deserialize_struct64_32le
79 {
80 uint8_t buf[12] = {
81 0x00, 0x5e, 0xd0, 0xb2,
82 0x10, 0x27,
83 0x64,
84 0x0d,
85 0x41, 0x42, 0x43,
86 };
87 struct foo64 foo;
88 deserialize_struct64(&foo, struct foo32, visit_foo_members, buf, false,
89 !HOST_LITTLE_ENDIAN);
90 ck_assert_uint_eq(foo.big, 3000000000);
91 ck_assert_uint_eq(foo.medium, 10000);
92 ck_assert_uint_eq(foo.small, 100);
93 ck_assert_uint_eq(foo.tiny, 13);
94 ck_assert_mem_eq(foo.array, "ABC", 3);
95 }
96
97 #test deserialize_struct64_32be
98 {
99 uint8_t buf[12] = {
100 0xb2, 0xd0, 0x5e, 0x00,
101 0x27, 0x10,
102 0x64,
103 0x0d,
104 0x41, 0x42, 0x43,
105 };
106 struct foo64 foo;
107 deserialize_struct64(&foo, struct foo32, visit_foo_members, buf, false,
108 HOST_LITTLE_ENDIAN);
109 ck_assert_uint_eq(foo.big, 3000000000);
110 ck_assert_uint_eq(foo.medium, 10000);
111 ck_assert_uint_eq(foo.small, 100);
112 ck_assert_uint_eq(foo.tiny, 13);
113 ck_assert_mem_eq(foo.array, "ABC", 3);
114 }
115
116 #tcase deserialize_struct64_inplace
117
118 #test deserialize_struct64_inplace_64le
119 {
120 uint8_t buf[24] = {
121 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00,
122 0xa0, 0x86, 0x01, 0x00,
123 0x20, 0x03,
124 0x0a,
125 0x41, 0x42, 0x43,
126 };
127 struct foo64 foo;
128 memcpy(&foo, buf, sizeof(buf));
129 deserialize_struct64_inplace(&foo, struct foo32, visit_foo_members,
130 true, !HOST_LITTLE_ENDIAN);
131 ck_assert_uint_eq(foo.big, 5000000000);
132 ck_assert_uint_eq(foo.medium, 100000);
133 ck_assert_uint_eq(foo.small, 800);
134 ck_assert_uint_eq(foo.tiny, 10);
135 ck_assert_mem_eq(foo.array, "ABC", 3);
136 }
137
138 #test deserialize_struct64_inplace_64be
139 {
140 uint8_t buf[24] = {
141 0x00, 0x00, 0x00, 0x01, 0x2a, 0x05, 0xf2, 0x00,
142 0x00, 0x01, 0x86, 0xa0,
143 0x03, 0x20,
144 0x0a,
145 0x41, 0x42, 0x43,
146 };
147 struct foo64 foo;
148 memcpy(&foo, buf, sizeof(buf));
149 deserialize_struct64_inplace(&foo, struct foo32, visit_foo_members,
150 true, HOST_LITTLE_ENDIAN);
151 ck_assert_uint_eq(foo.big, 5000000000);
152 ck_assert_uint_eq(foo.medium, 100000);
153 ck_assert_uint_eq(foo.small, 800);
154 ck_assert_uint_eq(foo.tiny, 10);
155 ck_assert_mem_eq(foo.array, "ABC", 3);
156 }
157
158 #test deserialize_struct64_inplace_32le
159 {
160 uint8_t buf[12] = {
161 0x00, 0x5e, 0xd0, 0xb2,
162 0x10, 0x27,
163 0x64,
164 0x0d,
165 0x41, 0x42, 0x43,
166 };
167 struct foo64 foo;
168 memcpy(&foo, buf, sizeof(buf));
169 deserialize_struct64_inplace(&foo, struct foo32, visit_foo_members,
170 false, !HOST_LITTLE_ENDIAN);
171 ck_assert_uint_eq(foo.big, 3000000000);
172 ck_assert_uint_eq(foo.medium, 10000);
173 ck_assert_uint_eq(foo.small, 100);
174 ck_assert_uint_eq(foo.tiny, 13);
175 ck_assert_mem_eq(foo.array, "ABC", 3);
176 }
177
178 #test deserialize_struct64_inplace_32be
179 {
180 uint8_t buf[12] = {
181 0xb2, 0xd0, 0x5e, 0x00,
182 0x27, 0x10,
183 0x64,
184 0x0d,
185 0x41, 0x42, 0x43,
186 };
187 struct foo64 foo;
188 memcpy(&foo, buf, sizeof(buf));
189 deserialize_struct64_inplace(&foo, struct foo32, visit_foo_members,
190 false, HOST_LITTLE_ENDIAN);
191 ck_assert_uint_eq(foo.big, 3000000000);
192 ck_assert_uint_eq(foo.medium, 10000);
193 ck_assert_uint_eq(foo.small, 100);
194 ck_assert_uint_eq(foo.tiny, 13);
195 ck_assert_mem_eq(foo.array, "ABC", 3);
196 }