1 /* GLib testing framework examples and tests
2 * Copyright (C) 2008 Red Hat, Inc.
3 * Authors: Tomas Bzatek <tbzatek@redhat.com>
4 *
5 * This work is provided "as is"; redistribution and modification
6 * in whole or in part, in any medium, physical or electronic is
7 * permitted without restriction.
8 *
9 * This work is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12 *
13 * In no event shall the authors or contributors be liable for any
14 * direct, indirect, incidental, special, exemplary, or consequential
15 * damages (including, but not limited to, procurement of substitute
16 * goods or services; loss of use, data, or profits; or business
17 * interruption) however caused and on any theory of liability, whether
18 * in contract, strict liability, or tort (including negligence or
19 * otherwise) arising in any way out of the use of this software, even
20 * if advised of the possibility of such damage.
21 */
22
23 #include <glib/glib.h>
24 #include <gio/gio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #define MAX_LINES 0xFFF
29 #define MAX_LINES_BUFF 0xFFFFFF
30 #define MAX_BYTES_BINARY 0x100
31
32 static void
test_basic(void)33 test_basic (void)
34 {
35 GOutputStream *stream;
36 GOutputStream *base_stream;
37 gpointer data;
38 gint val;
39
40 data = g_malloc0 (MAX_LINES_BUFF);
41
42 /* initialize objects */
43 base_stream = g_memory_output_stream_new (data, MAX_LINES_BUFF, NULL, NULL);
44 stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
45
46 g_object_get (stream, "byte-order", &val, NULL);
47 g_assert_cmpint (val, ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
48 g_object_set (stream, "byte-order", G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN, NULL);
49 g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
50
51 g_object_unref (stream);
52 g_object_unref (base_stream);
53 g_free (data);
54 }
55
56 static void
test_read_lines(GDataStreamNewlineType newline_type)57 test_read_lines (GDataStreamNewlineType newline_type)
58 {
59 GOutputStream *stream;
60 GOutputStream *base_stream;
61 GError *error = NULL;
62 gpointer data;
63 char *lines;
64 int size;
65 int i;
66
67 #define TEST_STRING "some_text"
68
69 const char* endl[4] = {"\n", "\r", "\r\n", "\n"};
70
71
72 data = g_malloc0 (MAX_LINES_BUFF);
73 lines = g_malloc0 ((strlen (TEST_STRING) + strlen (endl[newline_type])) * MAX_LINES + 1);
74
75 /* initialize objects */
76 base_stream = g_memory_output_stream_new (data, MAX_LINES_BUFF, NULL, NULL);
77 stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
78
79
80 /* fill data */
81 for (i = 0; i < MAX_LINES; i++)
82 {
83 gboolean res;
84 char *s = g_strconcat (TEST_STRING, endl[newline_type], NULL);
85 res = g_data_output_stream_put_string (G_DATA_OUTPUT_STREAM (stream), s, NULL, &error);
86 g_stpcpy ((char*)(lines + i*strlen(s)), s);
87 g_assert_no_error (error);
88 g_assert (res == TRUE);
89 g_free (s);
90 }
91
92 /* Byte order testing */
93 g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
94 g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
95 g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
96 g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
97
98 /* compare data */
99 size = strlen (data);
100 g_assert_cmpint (size, <, MAX_LINES_BUFF);
101 g_assert_cmpstr ((char*)data, ==, lines);
102
103 g_object_unref (base_stream);
104 g_object_unref (stream);
105 g_free (data);
106 g_free (lines);
107 }
108
109 static void
test_read_lines_LF(void)110 test_read_lines_LF (void)
111 {
112 test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_LF);
113 }
114
115 static void
test_read_lines_CR(void)116 test_read_lines_CR (void)
117 {
118 test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR);
119 }
120
121 static void
test_read_lines_CR_LF(void)122 test_read_lines_CR_LF (void)
123 {
124 test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
125 }
126
127 enum TestDataType {
128 TEST_DATA_BYTE = 0,
129 TEST_DATA_INT16,
130 TEST_DATA_UINT16,
131 TEST_DATA_INT32,
132 TEST_DATA_UINT32,
133 TEST_DATA_INT64,
134 TEST_DATA_UINT64
135 };
136
137 static void
test_data_array(guchar * buffer,gsize len,enum TestDataType data_type,GDataStreamByteOrder byte_order)138 test_data_array (guchar *buffer, gsize len,
139 enum TestDataType data_type, GDataStreamByteOrder byte_order)
140 {
141 GOutputStream *stream;
142 GOutputStream *base_stream;
143 guchar *stream_data;
144
145 GError *error = NULL;
146 guint pos;
147 GDataStreamByteOrder native;
148 gboolean swap;
149 gboolean res;
150
151 /* create objects */
152 stream_data = g_malloc0 (len);
153 base_stream = g_memory_output_stream_new (stream_data, len, NULL, NULL);
154 stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
155 g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), byte_order);
156
157 /* Set flag to swap bytes if needed */
158 native = (G_BYTE_ORDER == G_BIG_ENDIAN) ? G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN : G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
159 swap = (byte_order != G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN) && (byte_order != native);
160
161 /* set len to length of buffer cast to actual type */
162 switch (data_type)
163 {
164 case TEST_DATA_BYTE:
165 break;
166 case TEST_DATA_INT16:
167 case TEST_DATA_UINT16:
168 g_assert_cmpint (len % 2, ==, 0);
169 G_GNUC_FALLTHROUGH;
170 case TEST_DATA_INT32:
171 case TEST_DATA_UINT32:
172 g_assert_cmpint (len % 4, ==, 0);
173 G_GNUC_FALLTHROUGH;
174 case TEST_DATA_INT64:
175 case TEST_DATA_UINT64:
176 g_assert_cmpint (len % 8, ==, 0);
177 len /= 8;
178 break;
179 default:
180 g_assert_not_reached ();
181 break;
182 }
183
184 /* Write data to the file */
185 for (pos = 0; pos < len; pos++)
186 {
187 switch (data_type)
188 {
189 case TEST_DATA_BYTE:
190 res = g_data_output_stream_put_byte (G_DATA_OUTPUT_STREAM (stream), buffer[pos], NULL, &error);
191 break;
192 case TEST_DATA_INT16:
193 res = g_data_output_stream_put_int16 (G_DATA_OUTPUT_STREAM (stream), ((gint16 *) buffer)[pos], NULL, &error);
194 break;
195 case TEST_DATA_UINT16:
196 res = g_data_output_stream_put_uint16 (G_DATA_OUTPUT_STREAM (stream), ((guint16 *) buffer)[pos], NULL, &error);
197 break;
198 case TEST_DATA_INT32:
199 res = g_data_output_stream_put_int32 (G_DATA_OUTPUT_STREAM (stream), ((gint32 *) buffer)[pos], NULL, &error);
200 break;
201 case TEST_DATA_UINT32:
202 res = g_data_output_stream_put_uint32 (G_DATA_OUTPUT_STREAM (stream), ((guint32 *) buffer)[pos], NULL, &error);
203 break;
204 case TEST_DATA_INT64:
205 res = g_data_output_stream_put_int64 (G_DATA_OUTPUT_STREAM (stream), ((gint64 *) buffer)[pos], NULL, &error);
206 break;
207 case TEST_DATA_UINT64:
208 res = g_data_output_stream_put_uint64 (G_DATA_OUTPUT_STREAM (stream), ((guint64 *) buffer)[pos], NULL, &error);
209 break;
210 default:
211 g_assert_not_reached ();
212 break;
213 }
214 g_assert_no_error (error);
215 g_assert_cmpint (res, ==, TRUE);
216 }
217
218 /* Compare data back */
219 for (pos = 0; pos < len; pos++)
220 {
221 switch (data_type)
222 {
223 case TEST_DATA_BYTE:
224 /* swapping unnecessary */
225 g_assert_cmpint (buffer[pos], ==, stream_data[pos]);
226 break;
227 case TEST_DATA_UINT16:
228 if (swap)
229 g_assert_cmpint (GUINT16_SWAP_LE_BE (((guint16 *) buffer)[pos]), ==, ((guint16 *) stream_data)[pos]);
230 else
231 g_assert_cmpint (((guint16 *) buffer)[pos], ==, ((guint16 *) stream_data)[pos]);
232 break;
233 case TEST_DATA_INT16:
234 if (swap)
235 g_assert_cmpint ((gint16) GUINT16_SWAP_LE_BE (((gint16 *) buffer)[pos]), ==, ((gint16 *) stream_data)[pos]);
236 else
237 g_assert_cmpint (((gint16 *) buffer)[pos], ==, ((gint16 *) stream_data)[pos]);
238 break;
239 case TEST_DATA_UINT32:
240 if (swap)
241 g_assert_cmpint (GUINT32_SWAP_LE_BE (((guint32 *) buffer)[pos]), ==, ((guint32 *) stream_data)[pos]);
242 else
243 g_assert_cmpint (((guint32 *) buffer)[pos], ==, ((guint32 *) stream_data)[pos]);
244 break;
245 case TEST_DATA_INT32:
246 if (swap)
247 g_assert_cmpint ((gint32) GUINT32_SWAP_LE_BE (((gint32 *) buffer)[pos]), ==, ((gint32 *) stream_data)[pos]);
248 else
249 g_assert_cmpint (((gint32 *) buffer)[pos], ==, ((gint32 *) stream_data)[pos]);
250 break;
251 case TEST_DATA_UINT64:
252 if (swap)
253 g_assert_cmpint (GUINT64_SWAP_LE_BE (((guint64 *) buffer)[pos]), ==, ((guint64 *) stream_data)[pos]);
254 else
255 g_assert_cmpint (((guint64 *) buffer)[pos], ==, ((guint64 *) stream_data)[pos]);
256 break;
257 case TEST_DATA_INT64:
258 if (swap)
259 g_assert_cmpint ((gint64) GUINT64_SWAP_LE_BE (((gint64 *) buffer)[pos]), ==, ((gint64 *) stream_data)[pos]);
260 else
261 g_assert_cmpint (((gint64 *) buffer)[pos], ==, ((gint64 *) stream_data)[pos]);
262 break;
263 default:
264 g_assert_not_reached ();
265 break;
266 }
267 }
268
269 g_object_unref (base_stream);
270 g_object_unref (stream);
271 g_free (stream_data);
272 }
273
274 static void
test_read_int(void)275 test_read_int (void)
276 {
277 GRand *randomizer;
278 gpointer buffer;
279 int i;
280
281 randomizer = g_rand_new ();
282 buffer = g_malloc0(MAX_BYTES_BINARY);
283
284 /* Fill in some random data */
285 for (i = 0; i < MAX_BYTES_BINARY; i++)
286 {
287 guchar x = 0;
288 while (! x) x = (guchar)g_rand_int (randomizer);
289 *(guchar*)((guchar*)buffer + sizeof (guchar) * i) = x;
290 }
291
292 for (i = 0; i < 3; i++)
293 {
294 int j;
295 for (j = 0; j <= TEST_DATA_UINT64; j++)
296 test_data_array (buffer, MAX_BYTES_BINARY, j, i);
297 }
298
299 g_rand_free (randomizer);
300 g_free (buffer);
301 }
302
303 static void
test_seek(void)304 test_seek (void)
305 {
306 GDataOutputStream *stream;
307 GMemoryOutputStream *base_stream;
308 GSeekable *seekable;
309 GError *error;
310 guchar *stream_data;
311 gsize len;
312 gboolean res;
313
314 len = 8;
315
316 /* create objects */
317 stream_data = g_malloc0 (len);
318 base_stream = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new (stream_data, len, NULL, NULL));
319 stream = g_data_output_stream_new (G_OUTPUT_STREAM (base_stream));
320 g_data_output_stream_set_byte_order (stream, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
321 seekable = G_SEEKABLE (stream);
322 g_assert (!g_seekable_can_truncate (seekable));
323 error = NULL;
324
325 /* Write */
326 g_assert_cmpint (g_seekable_tell (seekable), ==, 0);
327 res = g_data_output_stream_put_uint16 (stream, 0x0123, NULL, &error);
328 g_assert_no_error (error);
329 g_assert (res);
330 g_data_output_stream_put_uint16 (stream, 0x4567, NULL, NULL);
331 g_assert_cmpint (g_seekable_tell (seekable), ==, 4);
332 g_assert_cmpint (stream_data[0], ==, 0x01);
333 g_assert_cmpint (stream_data[1], ==, 0x23);
334 g_assert_cmpint (stream_data[2], ==, 0x45);
335 g_assert_cmpint (stream_data[3], ==, 0x67);
336 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 4);
337
338 /* Forward relative seek */
339 res = g_seekable_seek (seekable, 2, G_SEEK_CUR, NULL, &error);
340 g_assert_no_error (error);
341 g_assert (res);
342 g_assert_cmpint (g_seekable_tell (seekable), ==, 6);
343 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 4);
344 res = g_data_output_stream_put_uint16 (stream, 0x89AB, NULL, &error);
345 g_assert (res);
346 g_assert_cmpint (g_seekable_tell (seekable), ==, 8);
347 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 8);
348 g_assert_cmpint (stream_data[0], ==, 0x01);
349 g_assert_cmpint (stream_data[1], ==, 0x23);
350 g_assert_cmpint (stream_data[2], ==, 0x45);
351 g_assert_cmpint (stream_data[3], ==, 0x67);
352 g_assert_cmpint (stream_data[4], ==, 0x00);
353 g_assert_cmpint (stream_data[5], ==, 0x00);
354 g_assert_cmpint (stream_data[6], ==, 0x89);
355 g_assert_cmpint (stream_data[7], ==, 0xAB);
356
357 /* Backward relative seek */
358 res = g_seekable_seek (seekable, -3, G_SEEK_CUR, NULL, &error);
359 g_assert_no_error (error);
360 g_assert (res);
361 g_assert_cmpint (g_seekable_tell (seekable), ==, 5);
362 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 8);
363 res = g_data_output_stream_put_uint16 (stream, 0xCDEF, NULL, &error);
364 g_assert_no_error (error);
365 g_assert (res);
366 g_assert_cmpint (g_seekable_tell (seekable), ==, 7);
367 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 8);
368 g_assert_cmpint (stream_data[0], ==, 0x01);
369 g_assert_cmpint (stream_data[1], ==, 0x23);
370 g_assert_cmpint (stream_data[2], ==, 0x45);
371 g_assert_cmpint (stream_data[3], ==, 0x67);
372 g_assert_cmpint (stream_data[4], ==, 0x00);
373 g_assert_cmpint (stream_data[5], ==, 0xCD);
374 g_assert_cmpint (stream_data[6], ==, 0xEF);
375 g_assert_cmpint (stream_data[7], ==, 0xAB);
376
377 /* From start */
378 res = g_seekable_seek (seekable, 4, G_SEEK_SET, NULL, &error);
379 g_assert_no_error (error);
380 g_assert (res);
381 g_assert_cmpint (g_seekable_tell (seekable), ==, 4);
382 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 8);
383 res = g_data_output_stream_put_uint16 (stream, 0xFEDC, NULL, &error);
384 g_assert_no_error (error);
385 g_assert (res);
386 g_assert_cmpint (g_seekable_tell (seekable), ==, 6);
387 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 8);
388 g_assert_cmpint (stream_data[0], ==, 0x01);
389 g_assert_cmpint (stream_data[1], ==, 0x23);
390 g_assert_cmpint (stream_data[2], ==, 0x45);
391 g_assert_cmpint (stream_data[3], ==, 0x67);
392 g_assert_cmpint (stream_data[4], ==, 0xFE);
393 g_assert_cmpint (stream_data[5], ==, 0xDC);
394 g_assert_cmpint (stream_data[6], ==, 0xEF);
395 g_assert_cmpint (stream_data[7], ==, 0xAB);
396
397 /* From end */
398 res = g_seekable_seek (seekable, -4, G_SEEK_END, NULL, &error);
399 g_assert_no_error (error);
400 g_assert (res);
401 g_assert_cmpint (g_seekable_tell (seekable), ==, 4);
402 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 8);
403 res = g_data_output_stream_put_uint16 (stream, 0xBA87, NULL, &error);
404 g_assert_no_error (error);
405 g_assert (res);
406 g_assert_cmpint (g_seekable_tell (seekable), ==, 6);
407 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 8);
408 g_assert_cmpint (stream_data[0], ==, 0x01);
409 g_assert_cmpint (stream_data[1], ==, 0x23);
410 g_assert_cmpint (stream_data[2], ==, 0x45);
411 g_assert_cmpint (stream_data[3], ==, 0x67);
412 g_assert_cmpint (stream_data[4], ==, 0xBA);
413 g_assert_cmpint (stream_data[5], ==, 0x87);
414 g_assert_cmpint (stream_data[6], ==, 0xEF);
415 g_assert_cmpint (stream_data[7], ==, 0xAB);
416
417 g_object_unref (stream);
418 g_object_unref (base_stream);
419 g_free (stream_data);
420 }
421
422 static void
test_truncate(void)423 test_truncate (void)
424 {
425 GDataOutputStream *stream;
426 GMemoryOutputStream *base_stream;
427 GSeekable *seekable;
428 GError *error;
429 guchar *stream_data;
430 gsize len;
431 gboolean res;
432
433 len = 8;
434
435 /* Create objects */
436 stream_data = g_malloc0 (len);
437 base_stream = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new (stream_data, len, g_realloc, g_free));
438 stream = g_data_output_stream_new (G_OUTPUT_STREAM (base_stream));
439 g_data_output_stream_set_byte_order (stream, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
440 seekable = G_SEEKABLE (stream);
441 error = NULL;
442 g_assert (g_seekable_can_truncate (seekable));
443
444 /* Write */
445 g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, len);
446 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 0);
447 res = g_data_output_stream_put_uint16 (stream, 0x0123, NULL, &error);
448 g_assert_no_error (error);
449 g_assert (res);
450 res = g_data_output_stream_put_uint16 (stream, 0x4567, NULL, NULL);
451 g_assert_no_error (error);
452 g_assert (res);
453 g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, len);
454 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 4);
455 stream_data = g_memory_output_stream_get_data (base_stream);
456 g_assert_cmpint (stream_data[0], ==, 0x01);
457 g_assert_cmpint (stream_data[1], ==, 0x23);
458 g_assert_cmpint (stream_data[2], ==, 0x45);
459 g_assert_cmpint (stream_data[3], ==, 0x67);
460
461 /* Truncate at position */
462 res = g_seekable_truncate (seekable, 4, NULL, &error);
463 g_assert_no_error (error);
464 g_assert (res);
465 g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, 4);
466 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 4);
467 stream_data = g_memory_output_stream_get_data (base_stream);
468 g_assert_cmpint (stream_data[0], ==, 0x01);
469 g_assert_cmpint (stream_data[1], ==, 0x23);
470 g_assert_cmpint (stream_data[2], ==, 0x45);
471 g_assert_cmpint (stream_data[3], ==, 0x67);
472
473 /* Truncate beyond position */
474 res = g_seekable_truncate (seekable, 6, NULL, &error);
475 g_assert_no_error (error);
476 g_assert (res);
477 g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, 6);
478 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 6);
479 stream_data = g_memory_output_stream_get_data (base_stream);
480 g_assert_cmpint (stream_data[0], ==, 0x01);
481 g_assert_cmpint (stream_data[1], ==, 0x23);
482 g_assert_cmpint (stream_data[2], ==, 0x45);
483 g_assert_cmpint (stream_data[3], ==, 0x67);
484
485 /* Truncate before position */
486 res = g_seekable_truncate (seekable, 2, NULL, &error);
487 g_assert_no_error (error);
488 g_assert (res);
489 g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, 2);
490 g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 2);
491 stream_data = g_memory_output_stream_get_data (base_stream);
492 g_assert_cmpint (stream_data[0], ==, 0x01);
493 g_assert_cmpint (stream_data[1], ==, 0x23);
494
495 g_object_unref (stream);
496 g_object_unref (base_stream);
497 }
498
499 int
main(int argc,char * argv[])500 main (int argc,
501 char *argv[])
502 {
503 g_test_init (&argc, &argv, NULL);
504
505 g_test_add_func ("/data-output-stream/basic", test_basic);
506 g_test_add_func ("/data-output-stream/write-lines-LF", test_read_lines_LF);
507 g_test_add_func ("/data-output-stream/write-lines-CR", test_read_lines_CR);
508 g_test_add_func ("/data-output-stream/write-lines-CR-LF", test_read_lines_CR_LF);
509 g_test_add_func ("/data-output-stream/write-int", test_read_int);
510 g_test_add_func ("/data-output-stream/seek", test_seek);
511 g_test_add_func ("/data-output-stream/truncate", test_truncate);
512
513 return g_test_run();
514 }
515