Debian Codegraph @

check/internal-tests/stream_t.c

raw
1 /*
2 * FCML - Free Code Manipulation Library.
3 * Copyright (C) 2010-2020 Slawomir Wojtasiak
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 #include <stdlib.h>
21
22 #include <fcml_stream.h>
23
24 #include "stream_t.h"
25
26 fcml_uint8_t buffer[128];
27
28 fcml_bool fcml_tf_stream_suite_init(void) {
29 return FCML_TRUE;
30 }
31
32 fcml_bool fcml_tf_stream_suite_cleanup(void) {
33 return FCML_TRUE;
34 }
35
36 void fcml_tf_stream_read_byte(void) {
37
38 buffer[0] = 1;
39 buffer[1] = 2;
40 buffer[2] = 3;
41 buffer[3] = 4;
42
43 fcml_st_memory_stream stream;
44 stream.base_address = buffer;
45 stream.offset = 0;
46 stream.size = 4;
47
48 fcml_bool result;
49 fcml_uint8_t data;
50 data = fcml_fn_stream_read( &stream, &result );
51 STF_ASSERT( result == FCML_TRUE );
52 STF_ASSERT( data == 1 );
53
54 data = fcml_fn_stream_read( &stream, &result );
55 STF_ASSERT( result == FCML_TRUE );
56 STF_ASSERT( data == 2 );
57
58 data = fcml_fn_stream_read( &stream, &result );
59 STF_ASSERT( result == FCML_TRUE );
60 STF_ASSERT( data == 3 );
61
62 data = fcml_fn_stream_read( &stream, &result );
63 STF_ASSERT( result == FCML_TRUE );
64 STF_ASSERT( data == 4 );
65
66 data = fcml_fn_stream_read( &stream, &result );
67 STF_ASSERT( result == FCML_FALSE );
68
69 stream.base_address = buffer;
70 stream.offset = 0;
71 stream.size = 0;
72
73 data = fcml_fn_stream_read( &stream, &result );
74 STF_ASSERT( result == FCML_FALSE );
75 }
76
77 void fcml_tf_stream_write_byte(void) {
78
79 memset( buffer, 0, sizeof( buffer ) );
80
81 fcml_st_memory_stream stream;
82 stream.base_address = buffer;
83 stream.offset = 0;
84 stream.size = 4;
85
86 fcml_bool result;
87 result = fcml_fn_stream_write( &stream, 1 );
88 STF_ASSERT( result == FCML_TRUE );
89
90 result = fcml_fn_stream_write( &stream, 2 );
91 STF_ASSERT( result == FCML_TRUE );
92
93 result = fcml_fn_stream_write( &stream, 3 );
94 STF_ASSERT( result == FCML_TRUE );
95
96 result = fcml_fn_stream_write( &stream, 4 );
97 STF_ASSERT( result == FCML_TRUE );
98
99 result = fcml_fn_stream_write( &stream, 5 );
100 STF_ASSERT( result == FCML_FALSE );
101
102 STF_ASSERT(buffer[0] == 1);
103 STF_ASSERT(buffer[1] == 2);
104 STF_ASSERT(buffer[2] == 3);
105 STF_ASSERT(buffer[3] == 4);
106
107 stream.base_address = buffer;
108 stream.offset = 0;
109 stream.size = 0;
110
111 result = fcml_fn_stream_write( &stream, 1 );
112 STF_ASSERT( result == FCML_FALSE );
113 }
114
115 void fcml_tf_stream_read_word(void) {
116
117 buffer[0] = 1;
118 buffer[1] = 2;
119 buffer[2] = 3;
120 buffer[3] = 4;
121 buffer[4] = 5;
122 buffer[5] = 6;
123 buffer[6] = 7;
124 buffer[7] = 8;
125
126 fcml_st_memory_stream stream;
127 stream.base_address = buffer;
128 stream.offset = 0;
129 stream.size = 8;
130
131 fcml_bool result;
132 fcml_uint16_t data;
133 data = fcml_fn_stream_read_word( &stream, &result );
134 STF_ASSERT( result == FCML_TRUE );
135 STF_ASSERT( data == 0x0201 );
136
137 data = fcml_fn_stream_read_word( &stream, &result );
138 STF_ASSERT( result == FCML_TRUE );
139 STF_ASSERT( data == 0x0403 );
140
141 data = fcml_fn_stream_read_word( &stream, &result );
142 STF_ASSERT( result == FCML_TRUE );
143 STF_ASSERT( data == 0x0605 );
144
145 data = fcml_fn_stream_read_word( &stream, &result );
146 STF_ASSERT( result == FCML_TRUE );
147 STF_ASSERT( data == 0x0807 );
148
149 data = fcml_fn_stream_read_word( &stream, &result );
150 STF_ASSERT( result == FCML_FALSE );
151
152 stream.base_address = buffer;
153 stream.offset = 0;
154 stream.size = 1;
155
156 data = fcml_fn_stream_read_word( &stream, &result );
157 STF_ASSERT( result == FCML_FALSE );
158
159 stream.base_address = buffer;
160 stream.offset = 0;
161 stream.size = 0;
162
163 data = fcml_fn_stream_read_word( &stream, &result );
164 STF_ASSERT( result == FCML_FALSE );
165
166 stream.base_address = buffer;
167 stream.offset = 0;
168 stream.size = 2;
169
170 data = fcml_fn_stream_read_word( &stream, &result );
171 STF_ASSERT( result == FCML_TRUE );
172 STF_ASSERT( data == 0x0201 );
173 }
174
175 void fcml_tf_stream_write_word(void) {
176
177 memset( buffer, 0, sizeof( buffer ) );
178
179 fcml_st_memory_stream stream;
180 stream.base_address = buffer;
181 stream.offset = 0;
182 stream.size = 8;
183
184 fcml_bool result;
185 result = fcml_fn_stream_write_word( &stream, 0x0201 );
186 STF_ASSERT( result == FCML_TRUE );
187
188 result = fcml_fn_stream_write_word( &stream, 0x0403 );
189 STF_ASSERT( result == FCML_TRUE );
190
191 result = fcml_fn_stream_write_word( &stream, 0x0605 );
192 STF_ASSERT( result == FCML_TRUE );
193
194 result = fcml_fn_stream_write_word( &stream, 0x0807 );
195 STF_ASSERT( result == FCML_TRUE );
196
197 result = fcml_fn_stream_write_word( &stream, 0x0F09 );
198 STF_ASSERT( result == FCML_FALSE );
199
200 STF_ASSERT(buffer[0] == 1);
201 STF_ASSERT(buffer[1] == 2);
202 STF_ASSERT(buffer[2] == 3);
203 STF_ASSERT(buffer[3] == 4);
204 STF_ASSERT(buffer[4] == 5);
205 STF_ASSERT(buffer[5] == 6);
206 STF_ASSERT(buffer[6] == 7);
207 STF_ASSERT(buffer[7] == 8);
208
209 stream.base_address = buffer;
210 stream.offset = 0;
211 stream.size = 0;
212
213 result = fcml_fn_stream_write_word( &stream, 0x0102 );
214 STF_ASSERT( result == FCML_FALSE );
215
216 stream.base_address = buffer;
217 stream.offset = 0;
218 stream.size = 1;
219
220 result = fcml_fn_stream_write_word( &stream, 0x0102 );
221 STF_ASSERT( result == FCML_FALSE );
222
223 stream.base_address = buffer;
224 stream.offset = 0;
225 stream.size = 2;
226
227 result = fcml_fn_stream_write_word( &stream, 0x0A0B );
228 STF_ASSERT( result == FCML_TRUE );
229
230 STF_ASSERT(buffer[0] == 0x0B);
231 STF_ASSERT(buffer[1] == 0x0A);
232 }
233
234 void fcml_tf_stream_read_dword(void) {
235
236 buffer[0] = 1;
237 buffer[1] = 2;
238 buffer[2] = 3;
239 buffer[3] = 4;
240 buffer[4] = 5;
241 buffer[5] = 6;
242 buffer[6] = 7;
243 buffer[7] = 8;
244
245 fcml_st_memory_stream stream;
246 stream.base_address = buffer;
247 stream.offset = 0;
248 stream.size = 8;
249
250 fcml_bool result;
251 fcml_uint32_t data;
252 data = fcml_fn_stream_read_dword( &stream, &result );
253 STF_ASSERT( result == FCML_TRUE );
254 STF_ASSERT( data == 0x04030201 );
255
256 data = fcml_fn_stream_read_dword( &stream, &result );
257 STF_ASSERT( result == FCML_TRUE );
258 STF_ASSERT( data == 0x08070605 );
259
260 data = fcml_fn_stream_read_dword( &stream, &result );
261 STF_ASSERT( result == FCML_FALSE );
262
263 stream.base_address = buffer;
264 stream.offset = 0;
265 stream.size = 0;
266
267 data = fcml_fn_stream_read_dword( &stream, &result );
268 STF_ASSERT( result == FCML_FALSE );
269
270 stream.base_address = buffer;
271 stream.offset = 0;
272 stream.size = 3;
273
274 data = fcml_fn_stream_read_dword( &stream, &result );
275 STF_ASSERT( result == FCML_FALSE );
276
277 stream.base_address = buffer;
278 stream.offset = 0;
279 stream.size = 4;
280
281 data = fcml_fn_stream_read_dword( &stream, &result );
282 STF_ASSERT( result == FCML_TRUE );
283 STF_ASSERT( data == 0x04030201 );
284
285 }
286
287 void fcml_tf_stream_write_dword(void) {
288
289 memset( buffer, 0, sizeof( buffer ) );
290
291 fcml_st_memory_stream stream;
292 stream.base_address = buffer;
293 stream.offset = 0;
294 stream.size = 8;
295
296 fcml_bool result;
297 result = fcml_fn_stream_write_dword( &stream, 0x04030201 );
298 STF_ASSERT( result == FCML_TRUE );
299
300 result = fcml_fn_stream_write_dword( &stream, 0x08070605 );
301 STF_ASSERT( result == FCML_TRUE );
302
303 result = fcml_fn_stream_write_dword( &stream, 0x090A0B0C );
304 STF_ASSERT( result == FCML_FALSE );
305
306 STF_ASSERT(buffer[0] == 1);
307 STF_ASSERT(buffer[1] == 2);
308 STF_ASSERT(buffer[2] == 3);
309 STF_ASSERT(buffer[3] == 4);
310 STF_ASSERT(buffer[4] == 5);
311 STF_ASSERT(buffer[5] == 6);
312 STF_ASSERT(buffer[6] == 7);
313 STF_ASSERT(buffer[7] == 8);
314
315 stream.base_address = buffer;
316 stream.offset = 0;
317 stream.size = 0;
318
319 result = fcml_fn_stream_write_dword( &stream, 0x01020304 );
320 STF_ASSERT( result == FCML_FALSE );
321
322 stream.base_address = buffer;
323 stream.offset = 0;
324 stream.size = 3;
325
326 result = fcml_fn_stream_write_dword( &stream, 0x01020304 );
327 STF_ASSERT( result == FCML_FALSE );
328
329 stream.base_address = buffer;
330 stream.offset = 0;
331 stream.size = 4;
332
333 result = fcml_fn_stream_write_dword( &stream, 0x0A0B0C0D );
334 STF_ASSERT( result == FCML_TRUE );
335
336 STF_ASSERT(buffer[0] == 0x0D);
337 STF_ASSERT(buffer[1] == 0x0C);
338 STF_ASSERT(buffer[2] == 0x0B);
339 STF_ASSERT(buffer[3] == 0x0A);
340 }
341
342 void fcml_tf_stream_read_qword(void) {
343
344 buffer[0] = 1;
345 buffer[1] = 2;
346 buffer[2] = 3;
347 buffer[3] = 4;
348 buffer[4] = 5;
349 buffer[5] = 6;
350 buffer[6] = 7;
351 buffer[7] = 8;
352
353 buffer[8] = 9;
354 buffer[9] = 10;
355 buffer[10] = 11;
356 buffer[11] = 12;
357 buffer[12] = 13;
358 buffer[13] = 14;
359 buffer[14] = 15;
360 buffer[15] = 0;
361
362 fcml_st_memory_stream stream;
363 stream.base_address = buffer;
364 stream.offset = 0;
365 stream.size = 16;
366
367 fcml_bool result;
368 fcml_uint64_t data;
369 data = fcml_fn_stream_read_qword( &stream, &result );
370 STF_ASSERT( result == FCML_TRUE );
371 STF_ASSERT( data == 0x0807060504030201 );
372
373 data = fcml_fn_stream_read_qword( &stream, &result );
374 STF_ASSERT( result == FCML_TRUE );
375 STF_ASSERT( data == 0x000F0E0D0C0B0A09 );
376
377 data = fcml_fn_stream_read_qword( &stream, &result );
378 STF_ASSERT( result == FCML_FALSE );
379
380 stream.base_address = buffer;
381 stream.offset = 0;
382 stream.size = 0;
383
384 data = fcml_fn_stream_read_qword( &stream, &result );
385 STF_ASSERT( result == FCML_FALSE );
386
387 stream.base_address = buffer;
388 stream.offset = 0;
389 stream.size = 7;
390
391 data = fcml_fn_stream_read_qword( &stream, &result );
392 STF_ASSERT( result == FCML_FALSE );
393
394 stream.base_address = buffer;
395 stream.offset = 0;
396 stream.size = 8;
397
398 data = fcml_fn_stream_read_qword( &stream, &result );
399 STF_ASSERT( result == FCML_TRUE );
400 STF_ASSERT( data == 0x0807060504030201 );
401 }
402
403 void fcml_tf_stream_write_qword(void) {
404
405 memset( buffer, 0, sizeof( buffer ) );
406
407 fcml_st_memory_stream stream;
408 stream.base_address = buffer;
409 stream.offset = 0;
410 stream.size = 16;
411
412 fcml_bool result;
413 result = fcml_fn_stream_write_qword( &stream, 0x0706050403020100 );
414 STF_ASSERT( result == FCML_TRUE );
415
416 result = fcml_fn_stream_write_qword( &stream, 0x0F0E0D0C0B0A0908 );
417 STF_ASSERT( result == FCML_TRUE );
418
419 result = fcml_fn_stream_write_qword( &stream, 0x0706050403020100 );
420 STF_ASSERT( result == FCML_FALSE );
421
422 STF_ASSERT(buffer[0] == 0);
423 STF_ASSERT(buffer[1] == 1);
424 STF_ASSERT(buffer[2] == 2);
425 STF_ASSERT(buffer[3] == 3);
426 STF_ASSERT(buffer[4] == 4);
427 STF_ASSERT(buffer[5] == 5);
428 STF_ASSERT(buffer[6] == 6);
429 STF_ASSERT(buffer[7] == 7);
430
431 STF_ASSERT(buffer[8] == 8);
432 STF_ASSERT(buffer[9] == 9);
433 STF_ASSERT(buffer[10] == 0x0A);
434 STF_ASSERT(buffer[11] == 0x0B);
435 STF_ASSERT(buffer[12] == 0x0C);
436 STF_ASSERT(buffer[13] == 0x0D);
437 STF_ASSERT(buffer[14] == 0x0E);
438 STF_ASSERT(buffer[15] == 0x0F);
439
440 stream.base_address = buffer;
441 stream.offset = 0;
442 stream.size = 0;
443
444 result = fcml_fn_stream_write_qword( &stream, 0x0706050403020100 );
445 STF_ASSERT( result == FCML_FALSE );
446
447 stream.base_address = buffer;
448 stream.offset = 0;
449 stream.size = 7;
450
451 result = fcml_fn_stream_write_qword( &stream, 0x0706050403020100 );
452 STF_ASSERT( result == FCML_FALSE );
453
454 stream.base_address = buffer;
455 stream.offset = 0;
456 stream.size = 8;
457
458 memset(buffer, 0, sizeof(buffer));
459
460 result = fcml_fn_stream_write_qword( &stream, 0x0706050403020100 );
461 STF_ASSERT( result == FCML_TRUE );
462
463 STF_ASSERT(buffer[0] == 0);
464 STF_ASSERT(buffer[1] == 1);
465 STF_ASSERT(buffer[2] == 2);
466 STF_ASSERT(buffer[3] == 3);
467 STF_ASSERT(buffer[4] == 4);
468 STF_ASSERT(buffer[5] == 5);
469 STF_ASSERT(buffer[6] == 6);
470 STF_ASSERT(buffer[7] == 7);
471 }
472
473 void fcml_tf_stream_read_bytes(void) {
474
475 buffer[0] = 1;
476 buffer[1] = 2;
477 buffer[2] = 3;
478 buffer[3] = 4;
479 buffer[4] = 5;
480 buffer[5] = 6;
481 buffer[6] = 7;
482 buffer[7] = 8;
483 buffer[8] = 9;
484 buffer[9] = 10;
485 buffer[10] = 11;
486 buffer[11] = 12;
487 buffer[12] = 13;
488 buffer[13] = 14;
489 buffer[14] = 15;
490 buffer[15] = 0;
491
492 fcml_st_memory_stream stream;
493 stream.base_address = buffer;
494 stream.offset = 0;
495 stream.size = 16;
496
497 fcml_uint8_t buff[4];
498
499 fcml_uint64_t data = fcml_fn_stream_read_bytes( &stream, buff, sizeof( buff ) );
500 STF_ASSERT( data == 4 );
501 STF_ASSERT( buff[0] == 1 );
502 STF_ASSERT( buff[1] == 2 );
503 STF_ASSERT( buff[2] == 3 );
504 STF_ASSERT( buff[3] == 4 );
505
506 stream.size = 3;
507 stream.offset = 0;
508
509 memset( buff, 0, sizeof( buff ) );
510
511 data = fcml_fn_stream_read_bytes( &stream, buff, 4 );
512 STF_ASSERT( data == 3 );
513 STF_ASSERT( buff[0] == 1 );
514 STF_ASSERT( buff[1] == 2 );
515 STF_ASSERT( buff[2] == 3 );
516 STF_ASSERT( buff[3] == 0 );
517
518 stream.size = 0;
519 stream.offset = 0;
520
521 memset( buff, 0, sizeof( buff ) );
522
523 data = fcml_fn_stream_read_bytes( &stream, buff, 4 );
524 STF_ASSERT( data == 0 );
525 }
526
527
528 void fcml_tf_stream_write_bytes(void) {
529
530 memset( buffer, 0, sizeof( buffer ) );
531
532 fcml_uint8_t buff[5];
533
534 buff[0] = 1;
535 buff[1] = 2;
536 buff[2] = 3;
537 buff[3] = 4;
538 buff[4] = 5;
539
540 fcml_st_memory_stream stream;
541 stream.base_address = buffer;
542 stream.offset = 0;
543 stream.size = 16;
544
545 fcml_uint64_t data = fcml_fn_stream_write_bytes( &stream, buff, sizeof( buff ) );
546 STF_ASSERT( data == 5 );
547 STF_ASSERT( buffer[0] == 1 );
548 STF_ASSERT( buffer[1] == 2 );
549 STF_ASSERT( buffer[2] == 3 );
550 STF_ASSERT( buffer[3] == 4 );
551 STF_ASSERT( buffer[4] == 5 );
552
553 stream.size = 3;
554 stream.offset = 0;
555
556 memset( buffer, 0, sizeof( buffer ) );
557
558 data = fcml_fn_stream_write_bytes( &stream, buff, sizeof( buff ) );
559 STF_ASSERT( data == 3 );
560 STF_ASSERT( buffer[0] == 1 );
561 STF_ASSERT( buffer[1] == 2 );
562 STF_ASSERT( buffer[2] == 3 );
563 STF_ASSERT( buffer[3] == 0 );
564
565 stream.size = 0;
566 stream.offset = 0;
567
568 memset( buff, 0, sizeof( buff ) );
569
570 data = fcml_fn_stream_read_bytes( &stream, buff, 4 );
571 STF_ASSERT( data == 0 );
572 }
573
574 void fcml_tf_stream_peek() {
575
576 buffer[0] = 1;
577 buffer[1] = 2;
578 buffer[2] = 3;
579 buffer[3] = 4;
580
581 fcml_st_memory_stream stream;
582 stream.base_address = buffer;
583 stream.offset = 0;
584 stream.size = 4;
585
586 fcml_bool result;
587 fcml_uint8_t data;
588 data = fcml_fn_stream_read( &stream, &result );
589 STF_ASSERT( result == FCML_TRUE );
590 STF_ASSERT( data == 1 );
591 STF_ASSERT( stream.offset == 1 );
592
593 data = fcml_fn_stream_peek( &stream, &result );
594 STF_ASSERT( result == FCML_TRUE );
595 STF_ASSERT( data == 2 );
596 STF_ASSERT( stream.offset == 1 );
597
598 }
599
600 void fcml_tf_stream_seek() {
601
602 buffer[0] = 1;
603 buffer[1] = 2;
604 buffer[2] = 3;
605 buffer[3] = 4;
606
607 fcml_st_memory_stream stream;
608 stream.base_address = buffer;
609 stream.offset = 0;
610 stream.size = 4;
611
612 fcml_bool result;
613 fcml_uint8_t data;
614 data = fcml_fn_stream_read( &stream, &result );
615 STF_ASSERT( result == FCML_TRUE );
616 STF_ASSERT( data == 1 );
617 STF_ASSERT( stream.offset == 1 );
618
619 fcml_fn_stream_seek( &stream, 3, FCML_EN_ST_START );
620
621 data = fcml_fn_stream_read( &stream, &result );
622 STF_ASSERT( result == FCML_TRUE );
623 STF_ASSERT( data == 4 );
624 STF_ASSERT( stream.offset == 4 );
625
626 fcml_fn_stream_seek( &stream, -3, FCML_EN_ST_CURRENT );
627
628 data = fcml_fn_stream_read( &stream, &result );
629 STF_ASSERT( result == FCML_TRUE );
630 STF_ASSERT( data == 2 );
631 STF_ASSERT( stream.offset == 2 );
632
633 fcml_fn_stream_seek( &stream, -4, FCML_EN_ST_END );
634
635 data = fcml_fn_stream_read( &stream, &result );
636 STF_ASSERT( result == FCML_TRUE );
637 STF_ASSERT( data == 1 );
638 STF_ASSERT( stream.offset == 1 );
639
640 fcml_fn_stream_seek( &stream, -8, FCML_EN_ST_END );
641 STF_ASSERT( stream.offset == 0 );
642
643 fcml_fn_stream_seek( &stream, 8, FCML_EN_ST_END );
644 STF_ASSERT( stream.offset == 4 );
645
646 fcml_fn_stream_seek( &stream, 8, FCML_EN_ST_START );
647 STF_ASSERT( stream.offset == 4 );
648
649 }
650
651 void fcml_tf_stream_size() {
652
653 fcml_st_memory_stream stream;
654 stream.base_address = buffer;
655 stream.offset = 0;
656 stream.size = 4;
657
658 fcml_int32_t size = fcml_fn_stream_size( &stream );
659 STF_ASSERT( size == 4 );
660
661 stream.size = 5;
662
663 size = fcml_fn_stream_size( &stream );
664 STF_ASSERT( size == 5 );
665
666 stream.size = -1;
667
668 size = fcml_fn_stream_size( &stream );
669 STF_ASSERT( size == -1 );
670
671 stream.size = 5;
672 stream.offset = 3;
673
674 size = fcml_fn_stream_size( &stream );
675 STF_ASSERT( size == 2 );
676 }
677
678 void fcml_tf_stream_save_restore_point() {
679
680 fcml_st_memory_stream stream;
681 stream.base_address = buffer;
682 stream.offset = 2;
683 stream.size = 4;
684
685 fcml_stream_pointer point = fcml_fn_stream_save_point( &stream );
686
687 stream.offset = 1;
688
689 fcml_fn_stream_restore_point( &stream, point );
690
691 STF_ASSERT(stream.offset = 2);
692 }
693
694 fcml_stf_test_case fctl_ti_stream[] = {
695 { "fcml_tf_stream_read_byte", fcml_tf_stream_read_byte },
696 { "fcml_tf_stream_write_byte", fcml_tf_stream_write_byte },
697 { "fcml_tf_stream_read_word", fcml_tf_stream_read_word },
698 { "fcml_tf_stream_write_word", fcml_tf_stream_write_word },
699 { "fcml_tf_stream_read_dword", fcml_tf_stream_read_dword },
700 { "fcml_tf_stream_write_dword", fcml_tf_stream_write_dword },
701 { "fcml_tf_stream_read_qword", fcml_tf_stream_read_qword },
702 { "fcml_tf_stream_write_qword", fcml_tf_stream_write_qword },
703 { "fcml_tf_stream_read_bytes", fcml_tf_stream_read_bytes },
704 { "fcml_tf_stream_write_bytes", fcml_tf_stream_write_bytes },
705 { "fcml_tf_stream_peek", fcml_tf_stream_peek },
706 { "fcml_tf_stream_seek", fcml_tf_stream_seek },
707 { "fcml_tf_stream_size", fcml_tf_stream_size },
708 { "fcml_tf_stream_save_restore_point", fcml_tf_stream_save_restore_point },
709 FCML_STF_NULL_TEST
710 };
711
712 fcml_stf_test_suite fctl_si_stream = {
713 "suite-stream", fcml_tf_stream_suite_init, fcml_tf_stream_suite_cleanup, fctl_ti_stream
714 };
715
716