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 |
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 (object: stream, first_property_name: "byte-order" , &val, NULL); |
47 | g_assert_cmpint (val, ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN); |
48 | g_object_set (object: stream, first_property_name: "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 (object: stream); |
52 | g_object_unref (object: base_stream); |
53 | g_free (mem: data); |
54 | } |
55 | |
56 | static void |
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 (n_bytes: (strlen (TEST_STRING) + strlen (s: 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), str: s, NULL, error: &error); |
86 | g_stpcpy (dest: (char*)(lines + i*strlen(s: s)), src: s); |
87 | g_assert_no_error (error); |
88 | g_assert (res == TRUE); |
89 | g_free (mem: s); |
90 | } |
91 | |
92 | /* Byte order testing */ |
93 | g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), order: 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), order: 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 (s: data); |
100 | g_assert_cmpint (size, <, MAX_LINES_BUFF); |
101 | g_assert_cmpstr ((char*)data, ==, lines); |
102 | |
103 | g_object_unref (object: base_stream); |
104 | g_object_unref (object: stream); |
105 | g_free (mem: data); |
106 | g_free (mem: lines); |
107 | } |
108 | |
109 | static void |
110 | test_read_lines_LF (void) |
111 | { |
112 | test_read_lines (newline_type: G_DATA_STREAM_NEWLINE_TYPE_LF); |
113 | } |
114 | |
115 | static void |
116 | test_read_lines_CR (void) |
117 | { |
118 | test_read_lines (newline_type: G_DATA_STREAM_NEWLINE_TYPE_CR); |
119 | } |
120 | |
121 | static void |
122 | test_read_lines_CR_LF (void) |
123 | { |
124 | test_read_lines (newline_type: 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 |
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 (n_bytes: len); |
153 | base_stream = g_memory_output_stream_new (data: stream_data, size: 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), order: 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), data: buffer[pos], NULL, error: &error); |
191 | break; |
192 | case TEST_DATA_INT16: |
193 | res = g_data_output_stream_put_int16 (G_DATA_OUTPUT_STREAM (stream), data: ((gint16 *) buffer)[pos], NULL, error: &error); |
194 | break; |
195 | case TEST_DATA_UINT16: |
196 | res = g_data_output_stream_put_uint16 (G_DATA_OUTPUT_STREAM (stream), data: ((guint16 *) buffer)[pos], NULL, error: &error); |
197 | break; |
198 | case TEST_DATA_INT32: |
199 | res = g_data_output_stream_put_int32 (G_DATA_OUTPUT_STREAM (stream), data: ((gint32 *) buffer)[pos], NULL, error: &error); |
200 | break; |
201 | case TEST_DATA_UINT32: |
202 | res = g_data_output_stream_put_uint32 (G_DATA_OUTPUT_STREAM (stream), data: ((guint32 *) buffer)[pos], NULL, error: &error); |
203 | break; |
204 | case TEST_DATA_INT64: |
205 | res = g_data_output_stream_put_int64 (G_DATA_OUTPUT_STREAM (stream), data: ((gint64 *) buffer)[pos], NULL, error: &error); |
206 | break; |
207 | case TEST_DATA_UINT64: |
208 | res = g_data_output_stream_put_uint64 (G_DATA_OUTPUT_STREAM (stream), data: ((guint64 *) buffer)[pos], NULL, error: &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 (object: base_stream); |
270 | g_object_unref (object: stream); |
271 | g_free (mem: stream_data); |
272 | } |
273 | |
274 | static 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 (rand_: 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, data_type: j, byte_order: i); |
297 | } |
298 | |
299 | g_rand_free (rand_: randomizer); |
300 | g_free (mem: buffer); |
301 | } |
302 | |
303 | static 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 (n_bytes: 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, order: 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, data: 0x0123, NULL, error: &error); |
328 | g_assert_no_error (error); |
329 | g_assert (res); |
330 | g_data_output_stream_put_uint16 (stream, data: 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, offset: 2, type: G_SEEK_CUR, NULL, error: &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, data: 0x89AB, NULL, error: &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, offset: -3, type: G_SEEK_CUR, NULL, error: &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, data: 0xCDEF, NULL, error: &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, offset: 4, type: G_SEEK_SET, NULL, error: &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, data: 0xFEDC, NULL, error: &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, offset: -4, type: G_SEEK_END, NULL, error: &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, data: 0xBA87, NULL, error: &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 (object: stream); |
418 | g_object_unref (object: base_stream); |
419 | g_free (mem: stream_data); |
420 | } |
421 | |
422 | static 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 (n_bytes: 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, order: 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, data: 0x0123, NULL, error: &error); |
448 | g_assert_no_error (error); |
449 | g_assert (res); |
450 | res = g_data_output_stream_put_uint16 (stream, data: 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 (ostream: 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, offset: 4, NULL, error: &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 (ostream: 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, offset: 6, NULL, error: &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 (ostream: 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, offset: 2, NULL, error: &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 (ostream: base_stream); |
492 | g_assert_cmpint (stream_data[0], ==, 0x01); |
493 | g_assert_cmpint (stream_data[1], ==, 0x23); |
494 | |
495 | g_object_unref (object: stream); |
496 | g_object_unref (object: base_stream); |
497 | } |
498 | |
499 | int |
500 | main (int argc, |
501 | char *argv[]) |
502 | { |
503 | g_test_init (argc: &argc, argv: &argv, NULL); |
504 | |
505 | g_test_add_func (testpath: "/data-output-stream/basic" , test_func: test_basic); |
506 | g_test_add_func (testpath: "/data-output-stream/write-lines-LF" , test_func: test_read_lines_LF); |
507 | g_test_add_func (testpath: "/data-output-stream/write-lines-CR" , test_func: test_read_lines_CR); |
508 | g_test_add_func (testpath: "/data-output-stream/write-lines-CR-LF" , test_func: test_read_lines_CR_LF); |
509 | g_test_add_func (testpath: "/data-output-stream/write-int" , test_func: test_read_int); |
510 | g_test_add_func (testpath: "/data-output-stream/seek" , test_func: test_seek); |
511 | g_test_add_func (testpath: "/data-output-stream/truncate" , test_func: test_truncate); |
512 | |
513 | return g_test_run(); |
514 | } |
515 | |