1 /*
2 * Library btree_header type test program
3 *
4 * Copyright (C) 2020-2021, Joachim Metz <joachim.metz@gmail.com>
5 *
6 * Refer to AUTHORS for acknowledgements.
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <common.h>
23 #include <file_stream.h>
24 #include <types.h>
25
26 #if defined( HAVE_STDLIB_H ) || defined( WINAPI )
27 #include <stdlib.h>
28 #endif
29
30 #include "fsxfs_test_libcerror.h"
31 #include "fsxfs_test_libfsxfs.h"
32 #include "fsxfs_test_macros.h"
33 #include "fsxfs_test_memory.h"
34 #include "fsxfs_test_unused.h"
35
36 #include "../libfsxfs/libfsxfs_btree_header.h"
37 #include "../libfsxfs/libfsxfs_io_handle.h"
38
39 uint8_t fsxfs_test_btree_header_data1[ 16 ] = {
40 0x49, 0x41, 0x42, 0x33, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
41
42 #if defined( __GNUC__ ) && !defined( LIBFSXFS_DLL_IMPORT )
43
44 /* Tests the libfsxfs_btree_header_initialize function
45 * Returns 1 if successful or 0 if not
46 */
fsxfs_test_btree_header_initialize(void)47 int fsxfs_test_btree_header_initialize(
48 void )
49 {
50 libcerror_error_t *error = NULL;
51 libfsxfs_btree_header_t *btree_header = NULL;
52 int result = 0;
53
54 #if defined( HAVE_FSXFS_TEST_MEMORY )
55 int number_of_malloc_fail_tests = 1;
56 int number_of_memset_fail_tests = 1;
57 int test_number = 0;
58 #endif
59
60 /* Test regular cases
61 */
62 result = libfsxfs_btree_header_initialize(
63 &btree_header,
64 &error );
65
66 FSXFS_TEST_ASSERT_EQUAL_INT(
67 "result",
68 result,
69 1 );
70
71 FSXFS_TEST_ASSERT_IS_NOT_NULL(
72 "btree_header",
73 btree_header );
74
75 FSXFS_TEST_ASSERT_IS_NULL(
76 "error",
77 error );
78
79 result = libfsxfs_btree_header_free(
80 &btree_header,
81 &error );
82
83 FSXFS_TEST_ASSERT_EQUAL_INT(
84 "result",
85 result,
86 1 );
87
88 FSXFS_TEST_ASSERT_IS_NULL(
89 "btree_header",
90 btree_header );
91
92 FSXFS_TEST_ASSERT_IS_NULL(
93 "error",
94 error );
95
96 /* Test error cases
97 */
98 result = libfsxfs_btree_header_initialize(
99 NULL,
100 &error );
101
102 FSXFS_TEST_ASSERT_EQUAL_INT(
103 "result",
104 result,
105 -1 );
106
107 FSXFS_TEST_ASSERT_IS_NOT_NULL(
108 "error",
109 error );
110
111 libcerror_error_free(
112 &error );
113
114 btree_header = (libfsxfs_btree_header_t *) 0x12345678UL;
115
116 result = libfsxfs_btree_header_initialize(
117 &btree_header,
118 &error );
119
120 FSXFS_TEST_ASSERT_EQUAL_INT(
121 "result",
122 result,
123 -1 );
124
125 FSXFS_TEST_ASSERT_IS_NOT_NULL(
126 "error",
127 error );
128
129 libcerror_error_free(
130 &error );
131
132 btree_header = NULL;
133
134 #if defined( HAVE_FSXFS_TEST_MEMORY )
135
136 for( test_number = 0;
137 test_number < number_of_malloc_fail_tests;
138 test_number++ )
139 {
140 /* Test libfsxfs_btree_header_initialize with malloc failing
141 */
142 fsxfs_test_malloc_attempts_before_fail = test_number;
143
144 result = libfsxfs_btree_header_initialize(
145 &btree_header,
146 &error );
147
148 if( fsxfs_test_malloc_attempts_before_fail != -1 )
149 {
150 fsxfs_test_malloc_attempts_before_fail = -1;
151
152 if( btree_header != NULL )
153 {
154 libfsxfs_btree_header_free(
155 &btree_header,
156 NULL );
157 }
158 }
159 else
160 {
161 FSXFS_TEST_ASSERT_EQUAL_INT(
162 "result",
163 result,
164 -1 );
165
166 FSXFS_TEST_ASSERT_IS_NULL(
167 "btree_header",
168 btree_header );
169
170 FSXFS_TEST_ASSERT_IS_NOT_NULL(
171 "error",
172 error );
173
174 libcerror_error_free(
175 &error );
176 }
177 }
178 for( test_number = 0;
179 test_number < number_of_memset_fail_tests;
180 test_number++ )
181 {
182 /* Test libfsxfs_btree_header_initialize with memset failing
183 */
184 fsxfs_test_memset_attempts_before_fail = test_number;
185
186 result = libfsxfs_btree_header_initialize(
187 &btree_header,
188 &error );
189
190 if( fsxfs_test_memset_attempts_before_fail != -1 )
191 {
192 fsxfs_test_memset_attempts_before_fail = -1;
193
194 if( btree_header != NULL )
195 {
196 libfsxfs_btree_header_free(
197 &btree_header,
198 NULL );
199 }
200 }
201 else
202 {
203 FSXFS_TEST_ASSERT_EQUAL_INT(
204 "result",
205 result,
206 -1 );
207
208 FSXFS_TEST_ASSERT_IS_NULL(
209 "btree_header",
210 btree_header );
211
212 FSXFS_TEST_ASSERT_IS_NOT_NULL(
213 "error",
214 error );
215
216 libcerror_error_free(
217 &error );
218 }
219 }
220 #endif /* defined( HAVE_FSXFS_TEST_MEMORY ) */
221
222 return( 1 );
223
224 on_error:
225 if( error != NULL )
226 {
227 libcerror_error_free(
228 &error );
229 }
230 if( btree_header != NULL )
231 {
232 libfsxfs_btree_header_free(
233 &btree_header,
234 NULL );
235 }
236 return( 0 );
237 }
238
239 /* Tests the libfsxfs_btree_header_free function
240 * Returns 1 if successful or 0 if not
241 */
fsxfs_test_btree_header_free(void)242 int fsxfs_test_btree_header_free(
243 void )
244 {
245 libcerror_error_t *error = NULL;
246 int result = 0;
247
248 /* Test error cases
249 */
250 result = libfsxfs_btree_header_free(
251 NULL,
252 &error );
253
254 FSXFS_TEST_ASSERT_EQUAL_INT(
255 "result",
256 result,
257 -1 );
258
259 FSXFS_TEST_ASSERT_IS_NOT_NULL(
260 "error",
261 error );
262
263 libcerror_error_free(
264 &error );
265
266 return( 1 );
267
268 on_error:
269 if( error != NULL )
270 {
271 libcerror_error_free(
272 &error );
273 }
274 return( 0 );
275 }
276
277 /* Tests the libfsxfs_btree_header_read_data function
278 * Returns 1 if successful or 0 if not
279 */
fsxfs_test_btree_header_read_data(void)280 int fsxfs_test_btree_header_read_data(
281 void )
282 {
283 libcerror_error_t *error = NULL;
284 libfsxfs_btree_header_t *btree_header = NULL;
285 libfsxfs_io_handle_t *io_handle = NULL;
286 int result = 0;
287
288 /* Initialize test
289 */
290 result = libfsxfs_io_handle_initialize(
291 &io_handle,
292 &error );
293
294 FSXFS_TEST_ASSERT_EQUAL_INT(
295 "result",
296 result,
297 1 );
298
299 FSXFS_TEST_ASSERT_IS_NOT_NULL(
300 "io_handle",
301 io_handle );
302
303 FSXFS_TEST_ASSERT_IS_NULL(
304 "error",
305 error );
306
307 io_handle->format_version = 4;
308 io_handle->block_size = 1024;
309 io_handle->inode_size = 128;
310
311 result = libfsxfs_btree_header_initialize(
312 &btree_header,
313 &error );
314
315 FSXFS_TEST_ASSERT_EQUAL_INT(
316 "result",
317 result,
318 1 );
319
320 FSXFS_TEST_ASSERT_IS_NOT_NULL(
321 "btree_header",
322 btree_header );
323
324 FSXFS_TEST_ASSERT_IS_NULL(
325 "error",
326 error );
327
328 /* Test regular cases
329 */
330 result = libfsxfs_btree_header_read_data(
331 btree_header,
332 io_handle,
333 fsxfs_test_btree_header_data1,
334 16,
335 4,
336 &error );
337
338 FSXFS_TEST_ASSERT_EQUAL_INT(
339 "result",
340 result,
341 1 );
342
343 FSXFS_TEST_ASSERT_IS_NULL(
344 "error",
345 error );
346
347 /* Test error cases
348 */
349 result = libfsxfs_btree_header_read_data(
350 NULL,
351 io_handle,
352 fsxfs_test_btree_header_data1,
353 16,
354 4,
355 &error );
356
357 FSXFS_TEST_ASSERT_EQUAL_INT(
358 "result",
359 result,
360 -1 );
361
362 FSXFS_TEST_ASSERT_IS_NOT_NULL(
363 "error",
364 error );
365
366 libcerror_error_free(
367 &error );
368
369 result = libfsxfs_btree_header_read_data(
370 btree_header,
371 NULL,
372 fsxfs_test_btree_header_data1,
373 16,
374 4,
375 &error );
376
377 FSXFS_TEST_ASSERT_EQUAL_INT(
378 "result",
379 result,
380 -1 );
381
382 FSXFS_TEST_ASSERT_IS_NOT_NULL(
383 "error",
384 error );
385
386 libcerror_error_free(
387 &error );
388
389 result = libfsxfs_btree_header_read_data(
390 btree_header,
391 io_handle,
392 NULL,
393 16,
394 4,
395 &error );
396
397 FSXFS_TEST_ASSERT_EQUAL_INT(
398 "result",
399 result,
400 -1 );
401
402 FSXFS_TEST_ASSERT_IS_NOT_NULL(
403 "error",
404 error );
405
406 libcerror_error_free(
407 &error );
408
409 result = libfsxfs_btree_header_read_data(
410 btree_header,
411 io_handle,
412 fsxfs_test_btree_header_data1,
413 (size_t) SSIZE_MAX + 1,
414 4,
415 &error );
416
417 FSXFS_TEST_ASSERT_EQUAL_INT(
418 "result",
419 result,
420 -1 );
421
422 FSXFS_TEST_ASSERT_IS_NOT_NULL(
423 "error",
424 error );
425
426 libcerror_error_free(
427 &error );
428
429 result = libfsxfs_btree_header_read_data(
430 btree_header,
431 io_handle,
432 fsxfs_test_btree_header_data1,
433 0,
434 4,
435 &error );
436
437 FSXFS_TEST_ASSERT_EQUAL_INT(
438 "result",
439 result,
440 -1 );
441
442 FSXFS_TEST_ASSERT_IS_NOT_NULL(
443 "error",
444 error );
445
446 libcerror_error_free(
447 &error );
448
449 result = libfsxfs_btree_header_read_data(
450 btree_header,
451 io_handle,
452 fsxfs_test_btree_header_data1,
453 16,
454 0,
455 &error );
456
457 FSXFS_TEST_ASSERT_EQUAL_INT(
458 "result",
459 result,
460 -1 );
461
462 FSXFS_TEST_ASSERT_IS_NOT_NULL(
463 "error",
464 error );
465
466 libcerror_error_free(
467 &error );
468
469 /* Clean up
470 */
471 result = libfsxfs_btree_header_free(
472 &btree_header,
473 &error );
474
475 FSXFS_TEST_ASSERT_EQUAL_INT(
476 "result",
477 result,
478 1 );
479
480 FSXFS_TEST_ASSERT_IS_NULL(
481 "btree_header",
482 btree_header );
483
484 FSXFS_TEST_ASSERT_IS_NULL(
485 "error",
486 error );
487
488 result = libfsxfs_io_handle_free(
489 &io_handle,
490 &error );
491
492 FSXFS_TEST_ASSERT_EQUAL_INT(
493 "result",
494 result,
495 1 );
496
497 FSXFS_TEST_ASSERT_IS_NULL(
498 "io_handle",
499 io_handle );
500
501 FSXFS_TEST_ASSERT_IS_NULL(
502 "error",
503 error );
504
505 return( 1 );
506
507 on_error:
508 if( error != NULL )
509 {
510 libcerror_error_free(
511 &error );
512 }
513 if( btree_header != NULL )
514 {
515 libfsxfs_btree_header_free(
516 &btree_header,
517 NULL );
518 }
519 if( io_handle != NULL )
520 {
521 libfsxfs_io_handle_free(
522 &io_handle,
523 NULL );
524 }
525 return( 0 );
526 }
527
528 #endif /* defined( __GNUC__ ) && !defined( LIBFSXFS_DLL_IMPORT ) */
529
530 /* The main program
531 */
532 #if defined( HAVE_WIDE_SYSTEM_CHARACTER )
wmain(int argc FSXFS_TEST_ATTRIBUTE_UNUSED,wchar_t * const argv[]FSXFS_TEST_ATTRIBUTE_UNUSED)533 int wmain(
534 int argc FSXFS_TEST_ATTRIBUTE_UNUSED,
535 wchar_t * const argv[] FSXFS_TEST_ATTRIBUTE_UNUSED )
536 #else
537 int main(
538 int argc FSXFS_TEST_ATTRIBUTE_UNUSED,
539 char * const argv[] FSXFS_TEST_ATTRIBUTE_UNUSED )
540 #endif
541 {
542 FSXFS_TEST_UNREFERENCED_PARAMETER( argc )
543 FSXFS_TEST_UNREFERENCED_PARAMETER( argv )
544
545 #if defined( __GNUC__ ) && !defined( LIBFSXFS_DLL_IMPORT )
546
547 FSXFS_TEST_RUN(
548 "libfsxfs_btree_header_initialize",
549 fsxfs_test_btree_header_initialize );
550
551 FSXFS_TEST_RUN(
552 "libfsxfs_btree_header_free",
553 fsxfs_test_btree_header_free );
554
555 FSXFS_TEST_RUN(
556 "libfsxfs_btree_header_read_data",
557 fsxfs_test_btree_header_read_data );
558
559 #endif /* defined( __GNUC__ ) && !defined( LIBFSXFS_DLL_IMPORT ) */
560
561 return( EXIT_SUCCESS );
562
563 #if defined( __GNUC__ ) && !defined( LIBFSXFS_DLL_IMPORT )
564
565 on_error:
566 return( EXIT_FAILURE );
567
568 #endif /* defined( __GNUC__ ) && !defined( LIBFSXFS_DLL_IMPORT ) */
569 }
570
571