source: mainline/uspace/lib/riff/test/chunk.c

Last change on this file was ea459d4, checked in by Jiri Svoboda <jiri@…>, 5 years ago

Reading typeface from TPF file
  • Property mode set to 100644
File size: 15.3 KB
Line 
1/*
2 * Copyright (c) 2020 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <stdio.h>
30#include <pcut/pcut.h>
31#include <riff/chunk.h>
32#include <str.h>
33
34PCUT_INIT;
35
36PCUT_TEST_SUITE(chunk);
37
38enum {
39 CKID_dat1 = 0x31746164,
40 CKID_dat2 = 0x32746164,
41 LTYPE_lst1 = 0x3174736C,
42 LTYPE_lst2 = 0x3274736C
43};
44
45/** Write and read back RIFF file containing just empty RIFF chunk */
46PCUT_TEST(empty)
47{
48 char fname[L_tmpnam];
49 char *p;
50 riffw_t *rw;
51 riffr_t *rr;
52 riff_wchunk_t wriffck;
53 riff_rchunk_t rriffck;
54 errno_t rc;
55
56 p = tmpnam(fname);
57 PCUT_ASSERT_NOT_NULL(p);
58
59 /* Write RIFF file */
60
61 rc = riff_wopen(p, &rw);
62 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
63 PCUT_ASSERT_NOT_NULL(rw);
64
65 rc = riff_wchunk_start(rw, CKID_RIFF, &wriffck);
66 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
67
68 rc = riff_wchunk_end(rw, &wriffck);
69 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
70
71 rc = riff_wclose(rw);
72 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
73
74 /* Read back RIFF file */
75
76 rc = riff_ropen(p, &rriffck, &rr);
77 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
78 PCUT_ASSERT_NOT_NULL(rr);
79
80 PCUT_ASSERT_INT_EQUALS(CKID_RIFF, rriffck.ckid);
81 PCUT_ASSERT_INT_EQUALS(0, riff_rchunk_size(&rriffck));
82
83 rc = riff_rclose(rr);
84 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
85
86 (void) remove(p);
87}
88
89/** Write and read back RIFF file containing two data chunks */
90PCUT_TEST(data_chunks)
91{
92 char fname[L_tmpnam];
93 char *p;
94 char str1[] = "Hello";
95 char str2[] = "World!";
96 char buf[10];
97 size_t nread;
98 riffw_t *rw;
99 riffr_t *rr;
100 riff_wchunk_t wriffck;
101 riff_wchunk_t wdatack;
102 riff_rchunk_t rriffck;
103 riff_rchunk_t rdatack;
104 errno_t rc;
105
106 p = tmpnam(fname);
107 PCUT_ASSERT_NOT_NULL(p);
108
109 /* Write RIFF file */
110
111 rc = riff_wopen(p, &rw);
112 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
113 PCUT_ASSERT_NOT_NULL(rw);
114
115 rc = riff_wchunk_start(rw, CKID_RIFF, &wriffck);
116 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
117
118 /* Write first data chunk */
119
120 rc = riff_wchunk_start(rw, CKID_dat1, &wdatack);
121 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
122
123 rc = riff_write(rw, str1, str_size(str1));
124 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
125
126 rc = riff_wchunk_end(rw, &wdatack);
127 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
128
129 /* Write second data chunk */
130
131 rc = riff_wchunk_start(rw, CKID_dat2, &wdatack);
132 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
133
134 rc = riff_write(rw, str2, str_size(str2));
135 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
136
137 rc = riff_wchunk_end(rw, &wdatack);
138 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
139
140 rc = riff_wchunk_end(rw, &wriffck);
141 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
142
143 rc = riff_wclose(rw);
144 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
145
146 /* Read back RIFF file */
147
148 rc = riff_ropen(p, &rriffck, &rr);
149 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
150 PCUT_ASSERT_NOT_NULL(rr);
151
152 PCUT_ASSERT_INT_EQUALS(CKID_RIFF, rriffck.ckid);
153
154 /* Read first data chunk */
155
156 rc = riff_rchunk_start(&rriffck, &rdatack);
157 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
158 PCUT_ASSERT_INT_EQUALS(CKID_dat1, rdatack.ckid);
159
160 rc = riff_read(&rdatack, buf, sizeof(buf), &nread);
161 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
162 PCUT_ASSERT_INT_EQUALS(str_size(str1), nread);
163 PCUT_ASSERT_INT_EQUALS(0, memcmp(buf, str1, nread));
164
165 rc = riff_rchunk_end(&rdatack);
166 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
167
168 /* Read second data chunk */
169
170 rc = riff_rchunk_start(&rriffck, &rdatack);
171 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
172 PCUT_ASSERT_INT_EQUALS(CKID_dat2, rdatack.ckid);
173
174 rc = riff_read(&rdatack, buf, sizeof(buf), &nread);
175 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
176 PCUT_ASSERT_INT_EQUALS(str_size(str2), nread);
177 PCUT_ASSERT_INT_EQUALS(0, memcmp(buf, str2, nread));
178
179 rc = riff_rchunk_end(&rdatack);
180 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
181
182 rc = riff_rclose(rr);
183 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
184
185 (void) remove(p);
186}
187
188/** Write and read back RIFF file containing two list chunks */
189PCUT_TEST(list_chunks)
190{
191 char fname[L_tmpnam];
192 char *p;
193 riffw_t *rw;
194 riffr_t *rr;
195 riff_wchunk_t wriffck;
196 riff_wchunk_t wlistck;
197 riff_wchunk_t wdatack;
198 riff_rchunk_t rriffck;
199 riff_rchunk_t rlistck;
200 riff_rchunk_t rdatack;
201 uint32_t ltype;
202 errno_t rc;
203
204 p = tmpnam(fname);
205 PCUT_ASSERT_NOT_NULL(p);
206
207 /* Write RIFF file */
208
209 rc = riff_wopen(p, &rw);
210 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
211 PCUT_ASSERT_NOT_NULL(rw);
212
213 rc = riff_wchunk_start(rw, CKID_RIFF, &wriffck);
214 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
215
216 /* Write first list chunk with two data chunks */
217
218 rc = riff_wchunk_start(rw, CKID_LIST, &wlistck);
219 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
220
221 rc = riff_write_uint32(rw, LTYPE_lst1);
222 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
223
224 rc = riff_wchunk_start(rw, CKID_dat1, &wdatack);
225 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
226
227 rc = riff_wchunk_end(rw, &wdatack);
228 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
229
230 rc = riff_wchunk_start(rw, CKID_dat2, &wdatack);
231 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
232
233 rc = riff_wchunk_end(rw, &wdatack);
234 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
235
236 rc = riff_wchunk_end(rw, &wlistck);
237 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
238
239 /* Write second list chunk with one data chunk */
240
241 rc = riff_wchunk_start(rw, CKID_LIST, &wlistck);
242 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
243
244 rc = riff_write_uint32(rw, LTYPE_lst2);
245 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
246
247 rc = riff_wchunk_start(rw, CKID_dat1, &wdatack);
248 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
249
250 rc = riff_wchunk_end(rw, &wdatack);
251 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
252
253 rc = riff_wchunk_end(rw, &wlistck);
254 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
255
256 rc = riff_wchunk_end(rw, &wriffck);
257 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
258
259 rc = riff_wclose(rw);
260 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
261
262 /* Read back RIFF file */
263
264 rc = riff_ropen(p, &rriffck, &rr);
265 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
266 PCUT_ASSERT_NOT_NULL(rr);
267
268 PCUT_ASSERT_INT_EQUALS(CKID_RIFF, rriffck.ckid);
269
270 /* Read first list chunk with two data chunks */
271
272 rc = riff_rchunk_start(&rriffck, &rlistck);
273 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
274 PCUT_ASSERT_INT_EQUALS(CKID_LIST, rlistck.ckid);
275
276 rc = riff_read_uint32(&rlistck, &ltype);
277 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
278 PCUT_ASSERT_INT_EQUALS(LTYPE_lst1, ltype);
279
280 rc = riff_rchunk_start(&rlistck, &rdatack);
281 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
282 PCUT_ASSERT_INT_EQUALS(CKID_dat1, rdatack.ckid);
283
284 rc = riff_rchunk_end(&rdatack);
285 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
286
287 rc = riff_rchunk_start(&rlistck, &rdatack);
288 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
289 PCUT_ASSERT_INT_EQUALS(CKID_dat2, rdatack.ckid);
290
291 rc = riff_rchunk_end(&rdatack);
292 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
293
294 rc = riff_rchunk_start(&rlistck, &rdatack);
295 PCUT_ASSERT_ERRNO_VAL(ELIMIT, rc);
296
297 rc = riff_rchunk_end(&rlistck);
298 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
299
300 /* Read second list chunk with one data chunk */
301
302 rc = riff_rchunk_start(&rriffck, &rlistck);
303 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
304 PCUT_ASSERT_INT_EQUALS(CKID_LIST, rlistck.ckid);
305
306 rc = riff_read_uint32(&rlistck, &ltype);
307 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
308 PCUT_ASSERT_INT_EQUALS(LTYPE_lst2, ltype);
309
310 rc = riff_rchunk_start(&rlistck, &rdatack);
311 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
312 PCUT_ASSERT_INT_EQUALS(CKID_dat1, rdatack.ckid);
313
314 rc = riff_rchunk_end(&rdatack);
315 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
316
317 rc = riff_rchunk_start(&rlistck, &rdatack);
318 PCUT_ASSERT_ERRNO_VAL(ELIMIT, rc);
319
320 rc = riff_rchunk_start(&rlistck, &rdatack);
321 PCUT_ASSERT_ERRNO_VAL(ELIMIT, rc);
322
323 rc = riff_rchunk_end(&rlistck);
324 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
325
326 rc = riff_rclose(rr);
327 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
328
329 (void) remove(p);
330}
331
332/** Match specific chunk type in a RIFF file */
333PCUT_TEST(match_chunk)
334{
335 char fname[L_tmpnam];
336 char *p;
337 riffw_t *rw;
338 riffr_t *rr;
339 riff_wchunk_t wriffck;
340 riff_wchunk_t wdatack;
341 riff_rchunk_t rriffck;
342 riff_rchunk_t rdatack;
343 uint32_t rword;
344 errno_t rc;
345
346 p = tmpnam(fname);
347 PCUT_ASSERT_NOT_NULL(p);
348
349 /* Write RIFF file */
350
351 rc = riff_wopen(p, &rw);
352 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
353 PCUT_ASSERT_NOT_NULL(rw);
354
355 rc = riff_wchunk_start(rw, CKID_RIFF, &wriffck);
356 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
357
358 /* Write first data chunk */
359
360 rc = riff_wchunk_start(rw, CKID_dat1, &wdatack);
361 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
362
363 rc = riff_write_uint32(rw, 1);
364 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
365
366 rc = riff_wchunk_end(rw, &wdatack);
367 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
368
369 /* Write second data chunk */
370
371 rc = riff_wchunk_start(rw, CKID_dat2, &wdatack);
372 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
373
374 rc = riff_write_uint32(rw, 2);
375 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
376
377 rc = riff_wchunk_end(rw, &wdatack);
378 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
379
380 /* Write third data chunk */
381
382 rc = riff_wchunk_start(rw, CKID_dat1, &wdatack);
383 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
384
385 rc = riff_write_uint32(rw, 3);
386 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
387
388 rc = riff_wchunk_end(rw, &wdatack);
389 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
390
391 rc = riff_wchunk_end(rw, &wriffck);
392 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
393
394 rc = riff_wclose(rw);
395 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
396
397 /* Read back RIFF file */
398
399 rc = riff_ropen(p, &rriffck, &rr);
400 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
401 PCUT_ASSERT_NOT_NULL(rr);
402
403 PCUT_ASSERT_INT_EQUALS(CKID_RIFF, rriffck.ckid);
404
405 /* Match second data chunk */
406
407 rc = riff_rchunk_match(&rriffck, CKID_dat2, &rdatack);
408 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
409 PCUT_ASSERT_INT_EQUALS(CKID_dat2, rdatack.ckid);
410
411 rc = riff_read_uint32(&rdatack, &rword);
412 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
413
414 PCUT_ASSERT_INT_EQUALS(2, rword);
415
416 rc = riff_rchunk_end(&rdatack);
417 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
418
419 /* Try matching dat2 again (should not match) */
420
421 rc = riff_rchunk_match(&rriffck, CKID_dat2, &rdatack);
422 PCUT_ASSERT_ERRNO_VAL(ENOENT, rc);
423
424 /* Try matching dat1 again (but there's nothing left) */
425
426 rc = riff_rchunk_match(&rriffck, CKID_dat1, &rdatack);
427 PCUT_ASSERT_ERRNO_VAL(ENOENT, rc);
428
429 rc = riff_rclose(rr);
430 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
431
432 (void) remove(p);
433}
434
435/** Match specific LIST chunk type in a RIFF file */
436PCUT_TEST(list_match)
437{
438 char fname[L_tmpnam];
439 char *p;
440 riffw_t *rw;
441 riffr_t *rr;
442 riff_wchunk_t wriffck;
443 riff_wchunk_t wdatack;
444 riff_rchunk_t rriffck;
445 riff_rchunk_t rdatack;
446 uint32_t rword;
447 errno_t rc;
448
449 p = tmpnam(fname);
450 PCUT_ASSERT_NOT_NULL(p);
451
452 /* Write RIFF file */
453
454 rc = riff_wopen(p, &rw);
455 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
456 PCUT_ASSERT_NOT_NULL(rw);
457
458 rc = riff_wchunk_start(rw, CKID_RIFF, &wriffck);
459 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
460
461 /* Write first LIST chunk */
462
463 rc = riff_wchunk_start(rw, CKID_LIST, &wdatack);
464 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
465
466 rc = riff_write_uint32(rw, LTYPE_lst1);
467 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
468
469 rc = riff_write_uint32(rw, 1);
470 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
471
472 rc = riff_wchunk_end(rw, &wdatack);
473 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
474
475 /* Write second data chunk */
476
477 rc = riff_wchunk_start(rw, CKID_LIST, &wdatack);
478 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
479
480 rc = riff_write_uint32(rw, LTYPE_lst2);
481 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
482
483 rc = riff_write_uint32(rw, 2);
484 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
485
486 rc = riff_wchunk_end(rw, &wdatack);
487 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
488
489 /* Write third data chunk */
490
491 rc = riff_wchunk_start(rw, CKID_LIST, &wdatack);
492 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
493
494 rc = riff_write_uint32(rw, LTYPE_lst1);
495 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
496
497 rc = riff_write_uint32(rw, 3);
498 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
499
500 rc = riff_wchunk_end(rw, &wdatack);
501 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
502
503 rc = riff_wchunk_end(rw, &wriffck);
504 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
505
506 rc = riff_wclose(rw);
507 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
508
509 /* Read back RIFF file */
510
511 rc = riff_ropen(p, &rriffck, &rr);
512 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
513 PCUT_ASSERT_NOT_NULL(rr);
514
515 PCUT_ASSERT_INT_EQUALS(CKID_RIFF, rriffck.ckid);
516
517 /* Match second LIST chunk */
518
519 rc = riff_rchunk_list_match(&rriffck, LTYPE_lst2, &rdatack);
520 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
521
522 rc = riff_read_uint32(&rdatack, &rword);
523 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
524
525 PCUT_ASSERT_INT_EQUALS(2, rword);
526
527 rc = riff_rchunk_end(&rdatack);
528 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
529
530 /* Try matching lst2 again (should not match) */
531
532 rc = riff_rchunk_list_match(&rriffck, LTYPE_lst2, &rdatack);
533 PCUT_ASSERT_ERRNO_VAL(ENOENT, rc);
534
535 /* Try matching lst1 again (but there's nothing left) */
536
537 rc = riff_rchunk_list_match(&rriffck, LTYPE_lst1, &rdatack);
538 PCUT_ASSERT_ERRNO_VAL(ENOENT, rc);
539
540 rc = riff_rclose(rr);
541 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
542
543 (void) remove(p);
544}
545
546/** Seek back to different positions in a chunk */
547PCUT_TEST(rchunk_seek)
548{
549 char fname[L_tmpnam];
550 char *p;
551 riffw_t *rw;
552 riffr_t *rr;
553 riff_wchunk_t wriffck;
554 riff_wchunk_t wdatack;
555 riff_rchunk_t rriffck;
556 riff_rchunk_t rdatack;
557 uint32_t rword;
558 errno_t rc;
559
560 p = tmpnam(fname);
561 PCUT_ASSERT_NOT_NULL(p);
562
563 /* Write RIFF file */
564
565 rc = riff_wopen(p, &rw);
566 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
567 PCUT_ASSERT_NOT_NULL(rw);
568
569 rc = riff_wchunk_start(rw, CKID_RIFF, &wriffck);
570 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
571
572 /* Write data chunk */
573
574 rc = riff_wchunk_start(rw, CKID_dat1, &wdatack);
575 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
576
577 rc = riff_write_uint32(rw, 1);
578 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
579
580 rc = riff_write_uint32(rw, 2);
581 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
582
583 rc = riff_write_uint32(rw, 3);
584 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
585
586 rc = riff_write_uint32(rw, 4);
587 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
588
589 rc = riff_wchunk_end(rw, &wdatack);
590 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
591
592 rc = riff_wchunk_end(rw, &wriffck);
593 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
594
595 rc = riff_wclose(rw);
596 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
597
598 /* Read back RIFF file */
599
600 rc = riff_ropen(p, &rriffck, &rr);
601 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
602 PCUT_ASSERT_NOT_NULL(rr);
603
604 PCUT_ASSERT_INT_EQUALS(CKID_RIFF, rriffck.ckid);
605
606 /* Read data chunk */
607
608 rc = riff_rchunk_start(&rriffck, &rdatack);
609 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
610 PCUT_ASSERT_INT_EQUALS(CKID_dat1, rdatack.ckid);
611
612 rc = riff_read_uint32(&rdatack, &rword);
613 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
614 PCUT_ASSERT_INT_EQUALS(1, rword);
615
616 rc = riff_rchunk_end(&rdatack);
617 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
618
619 /* Try reading first word of data chunk again */
620
621 rc = riff_rchunk_seek(&rdatack, 0, SEEK_SET);
622 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
623
624 rc = riff_read_uint32(&rdatack, &rword);
625 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
626 PCUT_ASSERT_INT_EQUALS(1, rword);
627
628 /* Try reading last word of data chunk */
629
630 rc = riff_rchunk_seek(&rdatack, -4, SEEK_END);
631 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
632
633 rc = riff_read_uint32(&rdatack, &rword);
634 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
635 PCUT_ASSERT_INT_EQUALS(4, rword);
636
637 /* Try reading previous word of data chunk */
638
639 rc = riff_rchunk_seek(&rdatack, -8, SEEK_CUR);
640 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
641
642 rc = riff_read_uint32(&rdatack, &rword);
643 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
644 PCUT_ASSERT_INT_EQUALS(3, rword);
645
646 rc = riff_rclose(rr);
647 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
648
649 (void) remove(p);
650}
651
652PCUT_EXPORT(chunk);
Note: See TracBrowser for help on using the repository browser.