Debian Codegraph @

src/libqmi-glib/test/test-compat-utils.c

raw
1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details:
12 *
13 * Copyright (C) 2012 Aleksander Morgado <[email protected]>
14 */
15
16 #include <glib-object.h>
17 #include <string.h>
18 #include "qmi-utils.h"
19 #include "qmi-compat.h"
20
21 #ifndef QMI_DISABLE_DEPRECATED
22
23 static void
24 test_utils_uint8 (void)
25 {
26 static const guint8 in_buffer[8] = {
27 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
28 };
29 guint8 out_buffer[8] = { 0 };
30
31 guint16 in_buffer_size;
32 const guint8 *in_buffer_walker;
33 guint16 out_buffer_size;
34 guint8 *out_buffer_walker;
35
36 in_buffer_size = sizeof (in_buffer);
37 in_buffer_walker = &in_buffer[0];
38 out_buffer_size = sizeof (out_buffer);
39 out_buffer_walker = &out_buffer[0];
40
41 while (in_buffer_size) {
42 guint8 tmp;
43
44 qmi_utils_read_guint8_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
45 qmi_utils_write_guint8_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
46 }
47
48 g_assert_cmpuint (out_buffer_size, ==, 0);
49 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
50 }
51
52 static void
53 test_utils_int8 (void)
54 {
55 static const guint8 in_buffer[8] = {
56 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
57 };
58 guint8 out_buffer[8] = { 0 };
59
60 guint16 in_buffer_size;
61 const guint8 *in_buffer_walker;
62 guint16 out_buffer_size;
63 guint8 *out_buffer_walker;
64
65 in_buffer_size = sizeof (in_buffer);
66 in_buffer_walker = &in_buffer[0];
67 out_buffer_size = sizeof (out_buffer);
68 out_buffer_walker = &out_buffer[0];
69
70 while (in_buffer_size) {
71 gint8 tmp;
72
73 qmi_utils_read_gint8_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
74 qmi_utils_write_gint8_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
75 }
76
77 g_assert_cmpuint (out_buffer_size, ==, 0);
78 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
79 }
80
81 static void
82 test_utils_uint16_le (void)
83 {
84 static const guint8 in_buffer[8] = {
85 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
86 };
87 static const guint16 values[4] = {
88 0x500F, 0xE2EB, 0x00B6, 0x0000
89 };
90 guint8 out_buffer[8] = { 0 };
91
92 guint i;
93 guint16 in_buffer_size;
94 const guint8 *in_buffer_walker;
95 guint16 out_buffer_size;
96 guint8 *out_buffer_walker;
97
98 in_buffer_size = sizeof (in_buffer);
99 in_buffer_walker = &in_buffer[0];
100 out_buffer_size = sizeof (out_buffer);
101 out_buffer_walker = &out_buffer[0];
102 i = 0;
103
104 while (in_buffer_size) {
105 guint16 tmp;
106
107 qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
108 g_assert_cmpuint (tmp, ==, values[i++]);
109 qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
110 }
111
112 g_assert_cmpuint (out_buffer_size, ==, 0);
113 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
114 }
115
116 static void
117 test_utils_uint16_be (void)
118 {
119 static const guint8 in_buffer[8] = {
120 0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
121 };
122 static const guint16 values[4] = {
123 0x500F, 0xE2EB, 0x00B6, 0x0000
124 };
125 guint8 out_buffer[8] = { 0 };
126
127 guint i;
128 guint16 in_buffer_size;
129 const guint8 *in_buffer_walker;
130 guint16 out_buffer_size;
131 guint8 *out_buffer_walker;
132
133 in_buffer_size = sizeof (in_buffer);
134 in_buffer_walker = &in_buffer[0];
135 out_buffer_size = sizeof (out_buffer);
136 out_buffer_walker = &out_buffer[0];
137 i = 0;
138
139 while (in_buffer_size) {
140 guint16 tmp;
141
142 qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
143 g_assert_cmpuint (tmp, ==, values[i++]);
144 qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
145 }
146
147 g_assert_cmpuint (out_buffer_size, ==, 0);
148 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
149 }
150
151 static void
152 test_utils_int16_le (void)
153 {
154 static const guint8 in_buffer[8] = {
155 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
156 };
157 static const gint16 values[4] = {
158 0x500F, 0xE2EB, 0x00B6, 0x0000
159 };
160 guint8 out_buffer[8] = { 0 };
161
162 guint i;
163 guint16 in_buffer_size;
164 const guint8 *in_buffer_walker;
165 guint16 out_buffer_size;
166 guint8 *out_buffer_walker;
167
168 in_buffer_size = sizeof (in_buffer);
169 in_buffer_walker = &in_buffer[0];
170 out_buffer_size = sizeof (out_buffer);
171 out_buffer_walker = &out_buffer[0];
172 i = 0;
173
174 while (in_buffer_size) {
175 gint16 tmp;
176
177 qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
178 g_assert_cmpint (tmp, ==, values[i++]);
179 qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
180 }
181
182 g_assert_cmpuint (out_buffer_size, ==, 0);
183 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
184 }
185
186 static void
187 test_utils_int16_be (void)
188 {
189 static const guint8 in_buffer[8] = {
190 0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
191 };
192 static const gint16 values[4] = {
193 0x500F, 0xE2EB, 0x00B6, 0x0000
194 };
195 guint8 out_buffer[8] = { 0 };
196
197 guint i;
198 guint16 in_buffer_size;
199 const guint8 *in_buffer_walker;
200 guint16 out_buffer_size;
201 guint8 *out_buffer_walker;
202
203 in_buffer_size = sizeof (in_buffer);
204 in_buffer_walker = &in_buffer[0];
205 out_buffer_size = sizeof (out_buffer);
206 out_buffer_walker = &out_buffer[0];
207 i = 0;
208
209 while (in_buffer_size) {
210 gint16 tmp;
211
212 qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
213 g_assert_cmpint (tmp, ==, values[i++]);
214 qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
215 }
216
217 g_assert_cmpuint (out_buffer_size, ==, 0);
218 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
219 }
220
221 static void
222 test_utils_uint16_unaligned_le (void)
223 {
224 static const guint8 in_buffer[9] = {
225 0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
226 };
227 static guint16 values[4] = {
228 0x500F, 0xE2EB, 0x00B6, 0x0000
229 };
230 guint8 out_buffer[8] = { 0 };
231
232 guint i;
233 guint16 in_buffer_size;
234 const guint8 *in_buffer_walker;
235 guint16 out_buffer_size;
236 guint8 *out_buffer_walker;
237
238 in_buffer_size = sizeof (in_buffer) - 1;
239 in_buffer_walker = &in_buffer[1];
240 out_buffer_size = sizeof (out_buffer);
241 out_buffer_walker = &out_buffer[0];
242 i = 0;
243
244 while (in_buffer_size) {
245 guint16 tmp;
246
247 qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
248 g_assert_cmpuint (tmp, ==, values[i++]);
249 qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
250 }
251
252 g_assert_cmpuint (out_buffer_size, ==, 0);
253 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
254 }
255
256 static void
257 test_utils_uint16_unaligned_be (void)
258 {
259 static const guint8 in_buffer[9] = {
260 0x00, 0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
261 };
262 static guint16 values[4] = {
263 0x500F, 0xE2EB, 0x00B6, 0x0000
264 };
265 guint8 out_buffer[8] = { 0 };
266
267 guint i;
268 guint16 in_buffer_size;
269 const guint8 *in_buffer_walker;
270 guint16 out_buffer_size;
271 guint8 *out_buffer_walker;
272
273 in_buffer_size = sizeof (in_buffer) - 1;
274 in_buffer_walker = &in_buffer[1];
275 out_buffer_size = sizeof (out_buffer);
276 out_buffer_walker = &out_buffer[0];
277 i = 0;
278
279 while (in_buffer_size) {
280 guint16 tmp;
281
282 qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
283 g_assert_cmpuint (tmp, ==, values[i++]);
284 qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
285 }
286
287 g_assert_cmpuint (out_buffer_size, ==, 0);
288 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
289 }
290
291 static void
292 test_utils_int16_unaligned_le (void)
293 {
294 static const guint8 in_buffer[9] = {
295 0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
296 };
297 static gint16 values[4] = {
298 0x500F, 0xE2EB, 0x00B6, 0x0000
299 };
300 guint8 out_buffer[8] = { 0 };
301
302 guint i;
303 guint16 in_buffer_size;
304 const guint8 *in_buffer_walker;
305 guint16 out_buffer_size;
306 guint8 *out_buffer_walker;
307
308 in_buffer_size = sizeof (in_buffer) - 1;
309 in_buffer_walker = &in_buffer[1];
310 out_buffer_size = sizeof (out_buffer);
311 out_buffer_walker = &out_buffer[0];
312 i = 0;
313
314 while (in_buffer_size) {
315 gint16 tmp;
316
317 qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
318 g_assert_cmpint (tmp, ==, values[i++]);
319 qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
320 }
321
322 g_assert_cmpuint (out_buffer_size, ==, 0);
323 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
324 }
325
326 static void
327 test_utils_int16_unaligned_be (void)
328 {
329 static const guint8 in_buffer[9] = {
330 0x00, 0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
331 };
332 static gint16 values[4] = {
333 0x500F, 0xE2EB, 0x00B6, 0x0000
334 };
335 guint8 out_buffer[8] = { 0 };
336
337 guint i;
338 guint16 in_buffer_size;
339 const guint8 *in_buffer_walker;
340 guint16 out_buffer_size;
341 guint8 *out_buffer_walker;
342
343 in_buffer_size = sizeof (in_buffer) - 1;
344 in_buffer_walker = &in_buffer[1];
345 out_buffer_size = sizeof (out_buffer);
346 out_buffer_walker = &out_buffer[0];
347 i = 0;
348
349 while (in_buffer_size) {
350 gint16 tmp;
351
352 qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
353 g_assert_cmpint (tmp, ==, values[i++]);
354 qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
355 }
356
357 g_assert_cmpuint (out_buffer_size, ==, 0);
358 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
359 }
360
361 static void
362 test_utils_uint32_le (void)
363 {
364 static const guint8 in_buffer[8] = {
365 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
366 };
367 static const guint32 values[2] = {
368 0xE2EB500F, 0x000000B6
369 };
370 guint8 out_buffer[8] = { 0 };
371
372 guint i;
373 guint16 in_buffer_size;
374 const guint8 *in_buffer_walker;
375 guint16 out_buffer_size;
376 guint8 *out_buffer_walker;
377
378 in_buffer_size = sizeof (in_buffer);
379 in_buffer_walker = &in_buffer[0];
380 out_buffer_size = sizeof (out_buffer);
381 out_buffer_walker = &out_buffer[0];
382 i = 0;
383
384 while (in_buffer_size) {
385 guint32 tmp;
386
387 qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
388 g_assert_cmpuint (tmp, ==, values[i++]);
389 qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
390 }
391
392 g_assert_cmpuint (out_buffer_size, ==, 0);
393 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
394 }
395
396 static void
397 test_utils_uint32_be (void)
398 {
399 static const guint8 in_buffer[8] = {
400 0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
401 };
402 static const guint32 values[2] = {
403 0xE2EB500F, 0x000000B6
404 };
405 guint8 out_buffer[8] = { 0 };
406
407 guint i;
408 guint16 in_buffer_size;
409 const guint8 *in_buffer_walker;
410 guint16 out_buffer_size;
411 guint8 *out_buffer_walker;
412
413 in_buffer_size = sizeof (in_buffer);
414 in_buffer_walker = &in_buffer[0];
415 out_buffer_size = sizeof (out_buffer);
416 out_buffer_walker = &out_buffer[0];
417 i = 0;
418
419 while (in_buffer_size) {
420 guint32 tmp;
421
422 qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
423 g_assert_cmpuint (tmp, ==, values[i++]);
424 qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
425 }
426
427 g_assert_cmpuint (out_buffer_size, ==, 0);
428 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
429 }
430
431 static void
432 test_utils_int32_le (void)
433 {
434 static const guint8 in_buffer[8] = {
435 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
436 };
437 static const gint32 values[2] = {
438 0xE2EB500F, 0x000000B6
439 };
440 guint8 out_buffer[8] = { 0 };
441
442 guint i;
443 guint16 in_buffer_size;
444 const guint8 *in_buffer_walker;
445 guint16 out_buffer_size;
446 guint8 *out_buffer_walker;
447
448 in_buffer_size = sizeof (in_buffer);
449 in_buffer_walker = &in_buffer[0];
450 out_buffer_size = sizeof (out_buffer);
451 out_buffer_walker = &out_buffer[0];
452 i = 0;
453
454 while (in_buffer_size) {
455 gint32 tmp;
456
457 qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
458 g_assert_cmpint (tmp, ==, values[i++]);
459 qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
460 }
461
462 g_assert_cmpuint (out_buffer_size, ==, 0);
463 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
464 }
465
466 static void
467 test_utils_int32_be (void)
468 {
469 static const guint8 in_buffer[8] = {
470 0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
471 };
472 static const gint32 values[2] = {
473 0xE2EB500F, 0x000000B6
474 };
475 guint8 out_buffer[8] = { 0 };
476
477 guint i;
478 guint16 in_buffer_size;
479 const guint8 *in_buffer_walker;
480 guint16 out_buffer_size;
481 guint8 *out_buffer_walker;
482
483 in_buffer_size = sizeof (in_buffer);
484 in_buffer_walker = &in_buffer[0];
485 out_buffer_size = sizeof (out_buffer);
486 out_buffer_walker = &out_buffer[0];
487 i = 0;
488
489 while (in_buffer_size) {
490 gint32 tmp;
491
492 qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
493 g_assert_cmpint (tmp, ==, values[i++]);
494 qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
495 }
496
497 g_assert_cmpuint (out_buffer_size, ==, 0);
498 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
499 }
500
501 static void
502 test_utils_uint32_unaligned_le (void)
503 {
504 static const guint8 in_buffer[9] = {
505 0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
506 };
507 static guint32 values[2] = {
508 0xE2EB500F, 0x000000B6
509 };
510 guint8 out_buffer[8] = { 0 };
511
512 guint i;
513 guint16 in_buffer_size;
514 const guint8 *in_buffer_walker;
515 guint16 out_buffer_size;
516 guint8 *out_buffer_walker;
517
518 in_buffer_size = sizeof (in_buffer) - 1;
519 in_buffer_walker = &in_buffer[1];
520 out_buffer_size = sizeof (out_buffer);
521 out_buffer_walker = &out_buffer[0];
522 i = 0;
523
524 while (in_buffer_size) {
525 guint32 tmp;
526
527 qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
528 g_assert_cmpuint (tmp, ==, values[i++]);
529 qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
530 }
531
532 g_assert_cmpuint (out_buffer_size, ==, 0);
533 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
534 }
535
536 static void
537 test_utils_uint32_unaligned_be (void)
538 {
539 static const guint8 in_buffer[9] = {
540 0x00, 0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
541 };
542 static guint32 values[2] = {
543 0xE2EB500F, 0x000000B6
544 };
545 guint8 out_buffer[8] = { 0 };
546
547 guint i;
548 guint16 in_buffer_size;
549 const guint8 *in_buffer_walker;
550 guint16 out_buffer_size;
551 guint8 *out_buffer_walker;
552
553 in_buffer_size = sizeof (in_buffer) - 1;
554 in_buffer_walker = &in_buffer[1];
555 out_buffer_size = sizeof (out_buffer);
556 out_buffer_walker = &out_buffer[0];
557 i = 0;
558
559 while (in_buffer_size) {
560 guint32 tmp;
561
562 qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
563 g_assert_cmpuint (tmp, ==, values[i++]);
564 qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
565 }
566
567 g_assert_cmpuint (out_buffer_size, ==, 0);
568 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
569 }
570
571 static void
572 test_utils_int32_unaligned_le (void)
573 {
574 static const guint8 in_buffer[9] = {
575 0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
576 };
577 static gint32 values[2] = {
578 0xE2EB500F, 0x000000B6
579 };
580 guint8 out_buffer[8] = { 0 };
581
582 guint i;
583 guint16 in_buffer_size;
584 const guint8 *in_buffer_walker;
585 guint16 out_buffer_size;
586 guint8 *out_buffer_walker;
587
588 in_buffer_size = sizeof (in_buffer) - 1;
589 in_buffer_walker = &in_buffer[1];
590 out_buffer_size = sizeof (out_buffer);
591 out_buffer_walker = &out_buffer[0];
592 i = 0;
593
594 while (in_buffer_size) {
595 gint32 tmp;
596
597 qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
598 g_assert_cmpint (tmp, ==, values[i++]);
599 qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
600 }
601
602 g_assert_cmpuint (out_buffer_size, ==, 0);
603 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
604 }
605
606 static void
607 test_utils_int32_unaligned_be (void)
608 {
609 static const guint8 in_buffer[9] = {
610 0x00, 0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
611 };
612 static gint32 values[2] = {
613 0xE2EB500F, 0x000000B6
614 };
615 guint8 out_buffer[8] = { 0 };
616
617 guint i;
618 guint16 in_buffer_size;
619 const guint8 *in_buffer_walker;
620 guint16 out_buffer_size;
621 guint8 *out_buffer_walker;
622
623 in_buffer_size = sizeof (in_buffer) - 1;
624 in_buffer_walker = &in_buffer[1];
625 out_buffer_size = sizeof (out_buffer);
626 out_buffer_walker = &out_buffer[0];
627 i = 0;
628
629 while (in_buffer_size) {
630 gint32 tmp;
631
632 qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
633 g_assert_cmpint (tmp, ==, values[i++]);
634 qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
635 }
636
637 g_assert_cmpuint (out_buffer_size, ==, 0);
638 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
639 }
640
641 static void
642 test_utils_uint64_le (void)
643 {
644 static const guint8 in_buffer[8] = {
645 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
646 };
647 static const guint64 values[1] = {
648 0x000000B6E2EB500FULL
649 };
650 guint8 out_buffer[8] = { 0 };
651
652 guint i;
653 guint16 in_buffer_size;
654 const guint8 *in_buffer_walker;
655 guint16 out_buffer_size;
656 guint8 *out_buffer_walker;
657
658 in_buffer_size = sizeof (in_buffer);
659 in_buffer_walker = &in_buffer[0];
660 out_buffer_size = sizeof (out_buffer);
661 out_buffer_walker = &out_buffer[0];
662 i = 0;
663
664 while (in_buffer_size) {
665 guint64 tmp;
666
667 qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
668 g_assert_cmpuint (tmp, ==, values[i++]);
669 qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
670 }
671
672 g_assert_cmpuint (out_buffer_size, ==, 0);
673 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
674 }
675
676 static void
677 test_utils_uint64_be (void)
678 {
679 static const guint8 in_buffer[8] = {
680 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
681 };
682 static const guint64 values[1] = {
683 0x000000B6E2EB500FULL
684 };
685 guint8 out_buffer[8] = { 0 };
686
687 guint i;
688 guint16 in_buffer_size;
689 const guint8 *in_buffer_walker;
690 guint16 out_buffer_size;
691 guint8 *out_buffer_walker;
692
693 in_buffer_size = sizeof (in_buffer);
694 in_buffer_walker = &in_buffer[0];
695 out_buffer_size = sizeof (out_buffer);
696 out_buffer_walker = &out_buffer[0];
697 i = 0;
698
699 while (in_buffer_size) {
700 guint64 tmp;
701
702 qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
703 g_assert_cmpuint (tmp, ==, values[i++]);
704 qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
705 }
706
707 g_assert_cmpuint (out_buffer_size, ==, 0);
708 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
709 }
710
711 static void
712 test_utils_int64_le (void)
713 {
714 static const guint8 in_buffer[8] = {
715 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
716 };
717 static const gint64 values[1] = {
718 0x000000B6E2EB500FLL
719 };
720 guint8 out_buffer[8] = { 0 };
721
722 guint i;
723 guint16 in_buffer_size;
724 const guint8 *in_buffer_walker;
725 guint16 out_buffer_size;
726 guint8 *out_buffer_walker;
727
728 in_buffer_size = sizeof (in_buffer);
729 in_buffer_walker = &in_buffer[0];
730 out_buffer_size = sizeof (out_buffer);
731 out_buffer_walker = &out_buffer[0];
732 i = 0;
733
734 while (in_buffer_size) {
735 gint64 tmp;
736
737 qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
738 g_assert_cmpint (tmp, ==, values[i++]);
739 qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
740 }
741
742 g_assert_cmpuint (out_buffer_size, ==, 0);
743 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
744 }
745
746 static void
747 test_utils_int64_be (void)
748 {
749 static const guint8 in_buffer[8] = {
750 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
751 };
752 static const gint64 values[1] = {
753 0x000000B6E2EB500FLL
754 };
755 guint8 out_buffer[8] = { 0 };
756
757 guint i;
758 guint16 in_buffer_size;
759 const guint8 *in_buffer_walker;
760 guint16 out_buffer_size;
761 guint8 *out_buffer_walker;
762
763 in_buffer_size = sizeof (in_buffer);
764 in_buffer_walker = &in_buffer[0];
765 out_buffer_size = sizeof (out_buffer);
766 out_buffer_walker = &out_buffer[0];
767 i = 0;
768
769 while (in_buffer_size) {
770 gint64 tmp;
771
772 qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
773 g_assert_cmpint (tmp, ==, values[i++]);
774 qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
775 }
776
777 g_assert_cmpuint (out_buffer_size, ==, 0);
778 g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
779 }
780
781 static void
782 test_utils_uint64_unaligned_le (void)
783 {
784 static const guint8 in_buffer[9] = {
785 0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
786 };
787 static guint64 values[1] = {
788 0x000000B6E2EB500FULL
789 };
790 guint8 out_buffer[8] = { 0 };
791
792 guint i;
793 guint16 in_buffer_size;
794 const guint8 *in_buffer_walker;
795 guint16 out_buffer_size;
796 guint8 *out_buffer_walker;
797
798 in_buffer_size = sizeof (in_buffer) - 1;
799 in_buffer_walker = &in_buffer[1];
800 out_buffer_size = sizeof (out_buffer);
801 out_buffer_walker = &out_buffer[0];
802 i = 0;
803
804 while (in_buffer_size) {
805 guint64 tmp;
806
807 qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
808 g_assert_cmpuint (tmp, ==, values[i++]);
809 qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
810 }
811
812 g_assert_cmpuint (out_buffer_size, ==, 0);
813 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
814 }
815
816 static void
817 test_utils_uint64_unaligned_be (void)
818 {
819 static const guint8 in_buffer[9] = {
820 0x00, 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
821 };
822 static guint64 values[1] = {
823 0x000000B6E2EB500FULL
824 };
825 guint8 out_buffer[8] = { 0 };
826
827 guint i;
828 guint16 in_buffer_size;
829 const guint8 *in_buffer_walker;
830 guint16 out_buffer_size;
831 guint8 *out_buffer_walker;
832
833 in_buffer_size = sizeof (in_buffer) - 1;
834 in_buffer_walker = &in_buffer[1];
835 out_buffer_size = sizeof (out_buffer);
836 out_buffer_walker = &out_buffer[0];
837 i = 0;
838
839 while (in_buffer_size) {
840 guint64 tmp;
841
842 qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
843 g_assert_cmpuint (tmp, ==, values[i++]);
844 qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
845 }
846
847 g_assert_cmpuint (out_buffer_size, ==, 0);
848 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
849 }
850
851 static void
852 test_utils_int64_unaligned_le (void)
853 {
854 static const guint8 in_buffer[9] = {
855 0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
856 };
857 static gint64 values[1] = {
858 0x000000B6E2EB500FLL
859 };
860 guint8 out_buffer[8] = { 0 };
861
862 guint i;
863 guint16 in_buffer_size;
864 const guint8 *in_buffer_walker;
865 guint16 out_buffer_size;
866 guint8 *out_buffer_walker;
867
868 in_buffer_size = sizeof (in_buffer) - 1;
869 in_buffer_walker = &in_buffer[1];
870 out_buffer_size = sizeof (out_buffer);
871 out_buffer_walker = &out_buffer[0];
872 i = 0;
873
874 while (in_buffer_size) {
875 gint64 tmp;
876
877 qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
878 g_assert_cmpint (tmp, ==, values[i++]);
879 qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
880 }
881
882 g_assert_cmpuint (out_buffer_size, ==, 0);
883 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
884 }
885
886 static void
887 test_utils_int64_unaligned_be (void)
888 {
889 static const guint8 in_buffer[9] = {
890 0x00, 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
891 };
892 static gint64 values[1] = {
893 0x000000B6E2EB500FLL
894 };
895 guint8 out_buffer[8] = { 0 };
896
897 guint i;
898 guint16 in_buffer_size;
899 const guint8 *in_buffer_walker;
900 guint16 out_buffer_size;
901 guint8 *out_buffer_walker;
902
903 in_buffer_size = sizeof (in_buffer) - 1;
904 in_buffer_walker = &in_buffer[1];
905 out_buffer_size = sizeof (out_buffer);
906 out_buffer_walker = &out_buffer[0];
907 i = 0;
908
909 while (in_buffer_size) {
910 gint64 tmp;
911
912 qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
913 g_assert_cmpint (tmp, ==, values[i++]);
914 qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
915 }
916
917 g_assert_cmpuint (out_buffer_size, ==, 0);
918 g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
919 }
920
921 static void
922 common_test_utils_uint_sized_le (guint n_bytes)
923 {
924 static const guint8 in_buffer[8] = {
925 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
926 };
927 guint64 value = 0x000000B6E2EB500FULL;
928 guint8 expected_out_buffer[8] = { 0 };
929 guint8 out_buffer[8] = { 0 };
930
931 guint64 tmp;
932 guint i;
933 guint16 in_buffer_size;
934 const guint8 *in_buffer_walker;
935 guint16 out_buffer_size;
936 guint8 *out_buffer_walker;
937
938 /* Build expected intermediate value */
939 tmp = 0xFF;
940 for (i = 1; i < n_bytes; i++) {
941 tmp <<= 8;
942 tmp |= 0xFF;
943 }
944 value &= tmp;
945
946 /* Build expected output buffer */
947 memcpy (expected_out_buffer, in_buffer, n_bytes);
948
949 in_buffer_size = sizeof (in_buffer);
950 in_buffer_walker = &in_buffer[0];
951 out_buffer_size = sizeof (out_buffer);
952 out_buffer_walker = &out_buffer[0];
953
954 qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
955 g_assert_cmpuint (tmp, ==, value);
956 qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
957
958 g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
959 g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
960 }
961
962 static void
963 test_utils_uint_sized_1_le (void)
964 {
965 common_test_utils_uint_sized_le (1);
966 }
967
968 static void
969 test_utils_uint_sized_2_le (void)
970 {
971 common_test_utils_uint_sized_le (2);
972 }
973
974 static void
975 test_utils_uint_sized_4_le (void)
976 {
977 common_test_utils_uint_sized_le (4);
978 }
979
980 static void
981 test_utils_uint_sized_8_le (void)
982 {
983 common_test_utils_uint_sized_le (8);
984 }
985
986 static void
987 common_test_utils_uint_sized_be (guint n_bytes)
988 {
989 static const guint8 in_buffer[8] = {
990 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
991 };
992 guint64 value = 0x000000B6E2EB500FULL;
993 guint8 expected_out_buffer[8] = { 0 };
994 guint8 out_buffer[8] = { 0 };
995 guint8 in_buffer_aux[8] = { 0 };
996
997 guint64 tmp;
998 guint i;
999 guint16 in_buffer_size;
1000 const guint8 *in_buffer_walker;
1001 guint16 out_buffer_size;
1002 guint8 *out_buffer_walker;
1003
1004 /* Build expected intermediate value */
1005 tmp = 0xFF;
1006 for (i = 1; i < n_bytes; i++) {
1007 tmp <<= 8;
1008 tmp |= 0xFF;
1009 }
1010 value &= tmp;
1011
1012 /* In BIG ENDIAN buffers, let's read only the bytes we want, starting from
1013 * the byte we want, not from the beginning of the input buffer. But we do
1014 * want to be aligned while reading, so we copy the bytes to read to the
1015 * beginning of an aux buffer */
1016 g_assert (n_bytes <= sizeof (in_buffer));
1017 memcpy (&in_buffer_aux[0], &in_buffer[sizeof (in_buffer) - n_bytes], n_bytes);
1018
1019 /* Build expected output buffer */
1020 memcpy (&expected_out_buffer[0], &in_buffer_aux[0], n_bytes);
1021
1022 in_buffer_size = sizeof (in_buffer);
1023 in_buffer_walker = &in_buffer_aux[0];
1024 out_buffer_size = sizeof (out_buffer);
1025 out_buffer_walker = &out_buffer[0];
1026
1027 qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
1028 g_assert_cmpuint (tmp, ==, value);
1029 qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
1030
1031 g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
1032 if (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) != 0) {
1033 g_print ("OUTPUT: %x, %x, %x, %x, %x, %x, %x, %x\n",
1034 out_buffer[0], out_buffer[1], out_buffer[2], out_buffer[3],
1035 out_buffer[4], out_buffer[5], out_buffer[6], out_buffer[7]);
1036 g_print ("EXPECTED: %x, %x, %x, %x, %x, %x, %x, %x\n",
1037 expected_out_buffer[0], expected_out_buffer[1], expected_out_buffer[2], expected_out_buffer[3],
1038 expected_out_buffer[4], expected_out_buffer[5], expected_out_buffer[6], expected_out_buffer[7]);
1039 }
1040 g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
1041 }
1042
1043 static void
1044 test_utils_uint_sized_1_be (void)
1045 {
1046 common_test_utils_uint_sized_be (1);
1047 }
1048
1049 static void
1050 test_utils_uint_sized_2_be (void)
1051 {
1052 common_test_utils_uint_sized_be (2);
1053 }
1054
1055 static void
1056 test_utils_uint_sized_4_be (void)
1057 {
1058 common_test_utils_uint_sized_be (4);
1059 }
1060
1061 static void
1062 test_utils_uint_sized_8_be (void)
1063 {
1064 common_test_utils_uint_sized_be (8);
1065 }
1066
1067 static void
1068 common_test_utils_uint_sized_unaligned_le (guint n_bytes)
1069 {
1070 static const guint8 in_buffer[9] = {
1071 0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
1072 };
1073 guint64 value = 0x000000B6E2EB500FULL;
1074 guint8 expected_out_buffer[8] = { 0 };
1075 guint8 out_buffer[8] = { 0 };
1076
1077 guint64 tmp;
1078 guint i;
1079 guint16 in_buffer_size;
1080 const guint8 *in_buffer_walker;
1081 guint16 out_buffer_size;
1082 guint8 *out_buffer_walker;
1083
1084 /* Build expected intermediate value */
1085 tmp = 0xFF;
1086 for (i = 1; i < n_bytes; i++) {
1087 tmp <<= 8;
1088 tmp |= 0xFF;
1089 }
1090 value &= tmp;
1091
1092 /* Build expected output buffer */
1093 memcpy (expected_out_buffer, &in_buffer[1], n_bytes);
1094
1095 in_buffer_size = sizeof (in_buffer) - 1;
1096 in_buffer_walker = &in_buffer[1];
1097 out_buffer_size = sizeof (out_buffer);
1098 out_buffer_walker = &out_buffer[0];
1099
1100 qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
1101 g_assert_cmpuint (tmp, ==, value);
1102 qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
1103
1104 g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
1105 g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
1106 }
1107
1108 static void
1109 test_utils_uint_sized_1_unaligned_le (void)
1110 {
1111 common_test_utils_uint_sized_unaligned_le (1);
1112 }
1113
1114 static void
1115 test_utils_uint_sized_2_unaligned_le (void)
1116 {
1117 common_test_utils_uint_sized_unaligned_le (2);
1118 }
1119
1120 static void
1121 test_utils_uint_sized_4_unaligned_le (void)
1122 {
1123 common_test_utils_uint_sized_unaligned_le (4);
1124 }
1125
1126 static void
1127 test_utils_uint_sized_8_unaligned_le (void)
1128 {
1129 common_test_utils_uint_sized_unaligned_le (8);
1130 }
1131
1132 static void
1133 common_test_utils_uint_sized_unaligned_be (guint n_bytes)
1134 {
1135 static const guint8 in_buffer[8] = {
1136 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
1137 };
1138 guint64 value = 0x000000B6E2EB500FULL;
1139 guint8 expected_out_buffer[8] = { 0 };
1140 guint8 out_buffer[8] = { 0 };
1141 guint8 in_buffer_aux[9] = { 0 };
1142
1143 guint64 tmp;
1144 guint i;
1145 guint16 in_buffer_size;
1146 const guint8 *in_buffer_walker;
1147 guint16 out_buffer_size;
1148 guint8 *out_buffer_walker;
1149
1150 /* Build expected intermediate value */
1151 tmp = 0xFF;
1152 for (i = 1; i < n_bytes; i++) {
1153 tmp <<= 8;
1154 tmp |= 0xFF;
1155 }
1156 value &= tmp;
1157
1158 /* In BIG ENDIAN buffers, let's read only the bytes we want, starting from
1159 * the byte we want, not from the beginning of the input buffer. But we do
1160 * not want to be aligned while reading, so we copy the bytes to read to
1161 * almost the beginning of an aux buffer */
1162 g_assert (n_bytes <= (sizeof (in_buffer)));
1163 memcpy (&in_buffer_aux[1], &in_buffer[sizeof (in_buffer) - n_bytes], n_bytes);
1164
1165 /* Build expected output buffer */
1166 memcpy (expected_out_buffer, &in_buffer_aux[1], n_bytes);
1167
1168 in_buffer_size = sizeof (in_buffer_aux) - 1;
1169 in_buffer_walker = &in_buffer_aux[1];
1170 out_buffer_size = sizeof (out_buffer);
1171 out_buffer_walker = &out_buffer[0];
1172
1173 qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
1174 g_assert_cmpuint (tmp, ==, value);
1175 qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
1176
1177 g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
1178 if (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) != 0) {
1179 g_print ("OUTPUT: %x, %x, %x, %x, %x, %x, %x, %x\n",
1180 out_buffer[0], out_buffer[1], out_buffer[2], out_buffer[3],
1181 out_buffer[4], out_buffer[5], out_buffer[6], out_buffer[7]);
1182 g_print ("EXPECTED: %x, %x, %x, %x, %x, %x, %x, %x\n",
1183 expected_out_buffer[0], expected_out_buffer[1], expected_out_buffer[2], expected_out_buffer[3],
1184 expected_out_buffer[4], expected_out_buffer[5], expected_out_buffer[6], expected_out_buffer[7]);
1185 }
1186 g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
1187 }
1188
1189 static void
1190 test_utils_uint_sized_1_unaligned_be (void)
1191 {
1192 common_test_utils_uint_sized_unaligned_be (1);
1193 }
1194
1195 static void
1196 test_utils_uint_sized_2_unaligned_be (void)
1197 {
1198 common_test_utils_uint_sized_unaligned_be (2);
1199 }
1200
1201 static void
1202 test_utils_uint_sized_4_unaligned_be (void)
1203 {
1204 common_test_utils_uint_sized_unaligned_be (4);
1205 }
1206
1207 static void
1208 test_utils_uint_sized_8_unaligned_be (void)
1209 {
1210 common_test_utils_uint_sized_unaligned_be (8);
1211 }
1212
1213 int main (int argc, char **argv)
1214 {
1215 g_test_init (&argc, &argv, NULL);
1216
1217 g_test_add_func ("/libqmi-glib/compat/utils/uint8", test_utils_uint8);
1218 g_test_add_func ("/libqmi-glib/compat/utils/int8", test_utils_int8);
1219
1220 g_test_add_func ("/libqmi-glib/compat/utils/uint16-LE", test_utils_uint16_le);
1221 g_test_add_func ("/libqmi-glib/compat/utils/uint16-BE", test_utils_uint16_be);
1222 g_test_add_func ("/libqmi-glib/compat/utils/int16-LE", test_utils_int16_le);
1223 g_test_add_func ("/libqmi-glib/compat/utils/int16-BE", test_utils_int16_be);
1224 g_test_add_func ("/libqmi-glib/compat/utils/uint16-unaligned-LE", test_utils_uint16_unaligned_le);
1225 g_test_add_func ("/libqmi-glib/compat/utils/uint16-unaligned-Be", test_utils_uint16_unaligned_be);
1226 g_test_add_func ("/libqmi-glib/compat/utils/int16-unaligned-LE", test_utils_int16_unaligned_le);
1227 g_test_add_func ("/libqmi-glib/compat/utils/int16-unaligned-BE", test_utils_int16_unaligned_be);
1228
1229 g_test_add_func ("/libqmi-glib/compat/utils/uint32-LE", test_utils_uint32_le);
1230 g_test_add_func ("/libqmi-glib/compat/utils/uint32-BE", test_utils_uint32_be);
1231 g_test_add_func ("/libqmi-glib/compat/utils/int32-LE", test_utils_int32_le);
1232 g_test_add_func ("/libqmi-glib/compat/utils/int32-BE", test_utils_int32_be);
1233 g_test_add_func ("/libqmi-glib/compat/utils/uint32/unaligned-LE", test_utils_uint32_unaligned_le);
1234 g_test_add_func ("/libqmi-glib/compat/utils/uint32/unaligned-BE", test_utils_uint32_unaligned_be);
1235 g_test_add_func ("/libqmi-glib/compat/utils/int32/unaligned-LE", test_utils_int32_unaligned_le);
1236 g_test_add_func ("/libqmi-glib/compat/utils/int32/unaligned-BE", test_utils_int32_unaligned_be);
1237
1238 g_test_add_func ("/libqmi-glib/compat/utils/uint64-LE", test_utils_uint64_le);
1239 g_test_add_func ("/libqmi-glib/compat/utils/uint64-BE", test_utils_uint64_be);
1240 g_test_add_func ("/libqmi-glib/compat/utils/int64-LE", test_utils_int64_le);
1241 g_test_add_func ("/libqmi-glib/compat/utils/int64-BE", test_utils_int64_be);
1242 g_test_add_func ("/libqmi-glib/compat/utils/uint64/unaligned-LE", test_utils_uint64_unaligned_le);
1243 g_test_add_func ("/libqmi-glib/compat/utils/uint64/unaligned-BE", test_utils_uint64_unaligned_be);
1244 g_test_add_func ("/libqmi-glib/compat/utils/int64/unaligned-LE", test_utils_int64_unaligned_le);
1245 g_test_add_func ("/libqmi-glib/compat/utils/int64/unaligned-BE", test_utils_int64_unaligned_be);
1246
1247 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-1-LE", test_utils_uint_sized_1_le);
1248 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-2-LE", test_utils_uint_sized_2_le);
1249 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-4-LE", test_utils_uint_sized_4_le);
1250 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-8-LE", test_utils_uint_sized_8_le);
1251 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-1-BE", test_utils_uint_sized_1_be);
1252 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-2-BE", test_utils_uint_sized_2_be);
1253 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-4-BE", test_utils_uint_sized_4_be);
1254 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-8-BE", test_utils_uint_sized_8_be);
1255 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-1-unaligned-LE", test_utils_uint_sized_1_unaligned_le);
1256 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-2-unaligned-LE", test_utils_uint_sized_2_unaligned_le);
1257 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-4-unaligned-LE", test_utils_uint_sized_4_unaligned_le);
1258 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-8-unaligned-LE", test_utils_uint_sized_8_unaligned_le);
1259 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-1-unaligned-BE", test_utils_uint_sized_1_unaligned_be);
1260 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-2-unaligned-BE", test_utils_uint_sized_2_unaligned_be);
1261 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-4-unaligned-BE", test_utils_uint_sized_4_unaligned_be);
1262 g_test_add_func ("/libqmi-glib/compat/utils/uint-sized-8-unaligned-BE", test_utils_uint_sized_8_unaligned_be);
1263
1264 return g_test_run ();
1265 }
1266
1267 #else
1268
1269 int main (int argc, char **argv)
1270 {
1271 return 0;
1272 }
1273
1274 #endif /* QMI_DISABLE_DEPRECATED */