1 /*
2 * Library byte_value_group type test program
3 *
4 * Copyright (C) 2014-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 "sigscan_test_libcerror.h"
31 #include "sigscan_test_libsigscan.h"
32 #include "sigscan_test_macros.h"
33 #include "sigscan_test_memory.h"
34 #include "sigscan_test_unused.h"
35
36 #include "../libsigscan/libsigscan_byte_value_group.h"
37
38 #if defined( __GNUC__ ) && !defined( LIBSIGSCAN_DLL_IMPORT )
39
40 /* Tests the libsigscan_byte_value_group_initialize function
41 * Returns 1 if successful or 0 if not
42 */
sigscan_test_byte_value_group_initialize(void)43 int sigscan_test_byte_value_group_initialize(
44 void )
45 {
46 libcerror_error_t *error = NULL;
47 libsigscan_byte_value_group_t *byte_value_group = NULL;
48 int result = 0;
49
50 #if defined( HAVE_SIGSCAN_TEST_MEMORY )
51 int number_of_malloc_fail_tests = 1;
52 int number_of_memset_fail_tests = 1;
53 int test_number = 0;
54 #endif
55
56 /* Test regular cases
57 */
58 result = libsigscan_byte_value_group_initialize(
59 &byte_value_group,
60 0,
61 &error );
62
63 SIGSCAN_TEST_ASSERT_EQUAL_INT(
64 "result",
65 result,
66 1 );
67
68 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
69 "byte_value_group",
70 byte_value_group );
71
72 SIGSCAN_TEST_ASSERT_IS_NULL(
73 "error",
74 error );
75
76 result = libsigscan_byte_value_group_free(
77 &byte_value_group,
78 &error );
79
80 SIGSCAN_TEST_ASSERT_EQUAL_INT(
81 "result",
82 result,
83 1 );
84
85 SIGSCAN_TEST_ASSERT_IS_NULL(
86 "byte_value_group",
87 byte_value_group );
88
89 SIGSCAN_TEST_ASSERT_IS_NULL(
90 "error",
91 error );
92
93 /* Test error cases
94 */
95 result = libsigscan_byte_value_group_initialize(
96 NULL,
97 0,
98 &error );
99
100 SIGSCAN_TEST_ASSERT_EQUAL_INT(
101 "result",
102 result,
103 -1 );
104
105 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
106 "error",
107 error );
108
109 libcerror_error_free(
110 &error );
111
112 byte_value_group = (libsigscan_byte_value_group_t *) 0x12345678UL;
113
114 result = libsigscan_byte_value_group_initialize(
115 &byte_value_group,
116 0,
117 &error );
118
119 SIGSCAN_TEST_ASSERT_EQUAL_INT(
120 "result",
121 result,
122 -1 );
123
124 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
125 "error",
126 error );
127
128 libcerror_error_free(
129 &error );
130
131 byte_value_group = NULL;
132
133 #if defined( HAVE_SIGSCAN_TEST_MEMORY )
134
135 for( test_number = 0;
136 test_number < number_of_malloc_fail_tests;
137 test_number++ )
138 {
139 /* Test libsigscan_byte_value_group_initialize with malloc failing
140 */
141 sigscan_test_malloc_attempts_before_fail = test_number;
142
143 result = libsigscan_byte_value_group_initialize(
144 &byte_value_group,
145 0,
146 &error );
147
148 if( sigscan_test_malloc_attempts_before_fail != -1 )
149 {
150 sigscan_test_malloc_attempts_before_fail = -1;
151
152 if( byte_value_group != NULL )
153 {
154 libsigscan_byte_value_group_free(
155 &byte_value_group,
156 NULL );
157 }
158 }
159 else
160 {
161 SIGSCAN_TEST_ASSERT_EQUAL_INT(
162 "result",
163 result,
164 -1 );
165
166 SIGSCAN_TEST_ASSERT_IS_NULL(
167 "byte_value_group",
168 byte_value_group );
169
170 SIGSCAN_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 libsigscan_byte_value_group_initialize with memset failing
183 */
184 sigscan_test_memset_attempts_before_fail = test_number;
185
186 result = libsigscan_byte_value_group_initialize(
187 &byte_value_group,
188 0,
189 &error );
190
191 if( sigscan_test_memset_attempts_before_fail != -1 )
192 {
193 sigscan_test_memset_attempts_before_fail = -1;
194
195 if( byte_value_group != NULL )
196 {
197 libsigscan_byte_value_group_free(
198 &byte_value_group,
199 NULL );
200 }
201 }
202 else
203 {
204 SIGSCAN_TEST_ASSERT_EQUAL_INT(
205 "result",
206 result,
207 -1 );
208
209 SIGSCAN_TEST_ASSERT_IS_NULL(
210 "byte_value_group",
211 byte_value_group );
212
213 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
214 "error",
215 error );
216
217 libcerror_error_free(
218 &error );
219 }
220 }
221 #endif /* defined( HAVE_SIGSCAN_TEST_MEMORY ) */
222
223 return( 1 );
224
225 on_error:
226 if( error != NULL )
227 {
228 libcerror_error_free(
229 &error );
230 }
231 if( byte_value_group != NULL )
232 {
233 libsigscan_byte_value_group_free(
234 &byte_value_group,
235 NULL );
236 }
237 return( 0 );
238 }
239
240 /* Tests the libsigscan_byte_value_group_free function
241 * Returns 1 if successful or 0 if not
242 */
sigscan_test_byte_value_group_free(void)243 int sigscan_test_byte_value_group_free(
244 void )
245 {
246 libcerror_error_t *error = NULL;
247 int result = 0;
248
249 /* Test error cases
250 */
251 result = libsigscan_byte_value_group_free(
252 NULL,
253 &error );
254
255 SIGSCAN_TEST_ASSERT_EQUAL_INT(
256 "result",
257 result,
258 -1 );
259
260 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
261 "error",
262 error );
263
264 libcerror_error_free(
265 &error );
266
267 return( 1 );
268
269 on_error:
270 if( error != NULL )
271 {
272 libcerror_error_free(
273 &error );
274 }
275 return( 0 );
276 }
277
278 /* Tests the libsigscan_byte_value_group_compare function
279 * Returns 1 if successful or 0 if not
280 */
sigscan_test_byte_value_group_compare(void)281 int sigscan_test_byte_value_group_compare(
282 void )
283 {
284 libcerror_error_t *error = NULL;
285 libsigscan_byte_value_group_t *first_byte_value_group = NULL;
286 libsigscan_byte_value_group_t *second_byte_value_group = NULL;
287 int result = 0;
288
289 /* Initialize test
290 */
291 result = libsigscan_byte_value_group_initialize(
292 &first_byte_value_group,
293 0,
294 &error );
295
296 SIGSCAN_TEST_ASSERT_EQUAL_INT(
297 "result",
298 result,
299 1 );
300
301 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
302 "first_byte_value_group",
303 first_byte_value_group );
304
305 SIGSCAN_TEST_ASSERT_IS_NULL(
306 "error",
307 error );
308
309 result = libsigscan_byte_value_group_initialize(
310 &second_byte_value_group,
311 0,
312 &error );
313
314 SIGSCAN_TEST_ASSERT_EQUAL_INT(
315 "result",
316 result,
317 1 );
318
319 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
320 "second_byte_value_group",
321 second_byte_value_group );
322
323 SIGSCAN_TEST_ASSERT_IS_NULL(
324 "error",
325 error );
326
327 /* Test regular cases
328 */
329 result = libsigscan_byte_value_group_compare(
330 first_byte_value_group,
331 second_byte_value_group,
332 &error );
333
334 SIGSCAN_TEST_ASSERT_EQUAL_INT(
335 "result",
336 result,
337 LIBCDATA_COMPARE_EQUAL );
338
339 SIGSCAN_TEST_ASSERT_IS_NULL(
340 "error",
341 error );
342
343 /* Test error cases
344 */
345 result = libsigscan_byte_value_group_compare(
346 NULL,
347 second_byte_value_group,
348 &error );
349
350 SIGSCAN_TEST_ASSERT_EQUAL_INT(
351 "result",
352 result,
353 -1 );
354
355 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
356 "error",
357 error );
358
359 libcerror_error_free(
360 &error );
361
362 result = libsigscan_byte_value_group_compare(
363 first_byte_value_group,
364 NULL,
365 &error );
366
367 SIGSCAN_TEST_ASSERT_EQUAL_INT(
368 "result",
369 result,
370 -1 );
371
372 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
373 "error",
374 error );
375
376 libcerror_error_free(
377 &error );
378
379 /* Clean up
380 */
381 result = libsigscan_byte_value_group_free(
382 &second_byte_value_group,
383 &error );
384
385 SIGSCAN_TEST_ASSERT_EQUAL_INT(
386 "result",
387 result,
388 1 );
389
390 SIGSCAN_TEST_ASSERT_IS_NULL(
391 "second_byte_value_group",
392 second_byte_value_group );
393
394 SIGSCAN_TEST_ASSERT_IS_NULL(
395 "error",
396 error );
397
398 result = libsigscan_byte_value_group_free(
399 &first_byte_value_group,
400 &error );
401
402 SIGSCAN_TEST_ASSERT_EQUAL_INT(
403 "result",
404 result,
405 1 );
406
407 SIGSCAN_TEST_ASSERT_IS_NULL(
408 "first_byte_value_group",
409 first_byte_value_group );
410
411 SIGSCAN_TEST_ASSERT_IS_NULL(
412 "error",
413 error );
414
415 return( 1 );
416
417 on_error:
418 if( error != NULL )
419 {
420 libcerror_error_free(
421 &error );
422 }
423 if( second_byte_value_group != NULL )
424 {
425 libsigscan_byte_value_group_free(
426 &second_byte_value_group,
427 NULL );
428 }
429 if( first_byte_value_group != NULL )
430 {
431 libsigscan_byte_value_group_free(
432 &first_byte_value_group,
433 NULL );
434 }
435 return( 0 );
436 }
437
438 /* Tests the libsigscan_byte_value_group_get_pattern_offset function
439 * Returns 1 if successful or 0 if not
440 */
sigscan_test_byte_value_group_get_pattern_offset(void)441 int sigscan_test_byte_value_group_get_pattern_offset(
442 void )
443 {
444 libcerror_error_t *error = NULL;
445 libsigscan_byte_value_group_t *byte_value_group = NULL;
446 off64_t pattern_offset = 0;
447 int result = 0;
448
449 /* Initialize test
450 */
451 result = libsigscan_byte_value_group_initialize(
452 &byte_value_group,
453 0,
454 &error );
455
456 SIGSCAN_TEST_ASSERT_EQUAL_INT(
457 "result",
458 result,
459 1 );
460
461 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
462 "byte_value_group",
463 byte_value_group );
464
465 SIGSCAN_TEST_ASSERT_IS_NULL(
466 "error",
467 error );
468
469 /* Test regular cases
470 */
471 result = libsigscan_byte_value_group_get_pattern_offset(
472 byte_value_group,
473 &pattern_offset,
474 &error );
475
476 SIGSCAN_TEST_ASSERT_EQUAL_INT(
477 "result",
478 result,
479 1 );
480
481 SIGSCAN_TEST_ASSERT_EQUAL_INT64(
482 "pattern_offset",
483 (int64_t) pattern_offset,
484 (int64_t) 0 );
485
486 SIGSCAN_TEST_ASSERT_IS_NULL(
487 "error",
488 error );
489
490 /* Test error cases
491 */
492 result = libsigscan_byte_value_group_get_pattern_offset(
493 NULL,
494 &pattern_offset,
495 &error );
496
497 SIGSCAN_TEST_ASSERT_EQUAL_INT(
498 "result",
499 result,
500 -1 );
501
502 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
503 "error",
504 error );
505
506 libcerror_error_free(
507 &error );
508
509 result = libsigscan_byte_value_group_get_pattern_offset(
510 byte_value_group,
511 NULL,
512 &error );
513
514 SIGSCAN_TEST_ASSERT_EQUAL_INT(
515 "result",
516 result,
517 -1 );
518
519 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
520 "error",
521 error );
522
523 libcerror_error_free(
524 &error );
525
526 /* Clean up
527 */
528 result = libsigscan_byte_value_group_free(
529 &byte_value_group,
530 &error );
531
532 SIGSCAN_TEST_ASSERT_EQUAL_INT(
533 "result",
534 result,
535 1 );
536
537 SIGSCAN_TEST_ASSERT_IS_NULL(
538 "byte_value_group",
539 byte_value_group );
540
541 SIGSCAN_TEST_ASSERT_IS_NULL(
542 "error",
543 error );
544
545 return( 1 );
546
547 on_error:
548 if( error != NULL )
549 {
550 libcerror_error_free(
551 &error );
552 }
553 if( byte_value_group != NULL )
554 {
555 libsigscan_byte_value_group_free(
556 &byte_value_group,
557 NULL );
558 }
559 return( 0 );
560 }
561
562 /* Tests the libsigscan_byte_value_group_insert_signature function
563 * Returns 1 if successful or 0 if not
564 */
sigscan_test_byte_value_group_insert_signature(void)565 int sigscan_test_byte_value_group_insert_signature(
566 void )
567 {
568 libcerror_error_t *error = NULL;
569 libsigscan_byte_value_group_t *byte_value_group = NULL;
570 libsigscan_signature_t *signature = NULL;
571 int result = 0;
572
573 /* Initialize test
574 */
575 result = libsigscan_signature_initialize(
576 &signature,
577 &error );
578
579 SIGSCAN_TEST_ASSERT_EQUAL_INT(
580 "result",
581 result,
582 1 );
583
584 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
585 "signature",
586 signature );
587
588 SIGSCAN_TEST_ASSERT_IS_NULL(
589 "error",
590 error );
591
592 result = libsigscan_signature_set(
593 signature,
594 "identifier",
595 10,
596 0,
597 (uint8_t *) "pattern",
598 7,
599 LIBSIGSCAN_SIGNATURE_FLAG_OFFSET_RELATIVE_FROM_START,
600 &error );
601
602 SIGSCAN_TEST_ASSERT_EQUAL_INT(
603 "result",
604 result,
605 1 );
606
607 SIGSCAN_TEST_ASSERT_IS_NULL(
608 "error",
609 error );
610
611 result = libsigscan_byte_value_group_initialize(
612 &byte_value_group,
613 0,
614 &error );
615
616 SIGSCAN_TEST_ASSERT_EQUAL_INT(
617 "result",
618 result,
619 1 );
620
621 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
622 "byte_value_group",
623 byte_value_group );
624
625 SIGSCAN_TEST_ASSERT_IS_NULL(
626 "error",
627 error );
628
629 /* Test regular cases
630 */
631 result = libsigscan_byte_value_group_insert_signature(
632 byte_value_group,
633 (uint8_t) 't',
634 signature,
635 &error );
636
637 SIGSCAN_TEST_ASSERT_EQUAL_INT(
638 "result",
639 result,
640 1 );
641
642 SIGSCAN_TEST_ASSERT_IS_NULL(
643 "error",
644 error );
645
646 /* Test error cases
647 */
648 result = libsigscan_byte_value_group_insert_signature(
649 NULL,
650 (uint8_t) 't',
651 signature,
652 &error );
653
654 SIGSCAN_TEST_ASSERT_EQUAL_INT(
655 "result",
656 result,
657 -1 );
658
659 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
660 "error",
661 error );
662
663 libcerror_error_free(
664 &error );
665
666 result = libsigscan_byte_value_group_insert_signature(
667 byte_value_group,
668 (uint8_t) 't',
669 NULL,
670 &error );
671
672 SIGSCAN_TEST_ASSERT_EQUAL_INT(
673 "result",
674 result,
675 -1 );
676
677 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
678 "error",
679 error );
680
681 libcerror_error_free(
682 &error );
683
684 /* Clean up
685 */
686 result = libsigscan_byte_value_group_free(
687 &byte_value_group,
688 &error );
689
690 SIGSCAN_TEST_ASSERT_EQUAL_INT(
691 "result",
692 result,
693 1 );
694
695 SIGSCAN_TEST_ASSERT_IS_NULL(
696 "byte_value_group",
697 byte_value_group );
698
699 SIGSCAN_TEST_ASSERT_IS_NULL(
700 "error",
701 error );
702
703 result = libsigscan_signature_free(
704 &signature,
705 &error );
706
707 SIGSCAN_TEST_ASSERT_EQUAL_INT(
708 "result",
709 result,
710 1 );
711
712 SIGSCAN_TEST_ASSERT_IS_NULL(
713 "signature",
714 signature );
715
716 SIGSCAN_TEST_ASSERT_IS_NULL(
717 "error",
718 error );
719
720 return( 1 );
721
722 on_error:
723 if( error != NULL )
724 {
725 libcerror_error_free(
726 &error );
727 }
728 if( byte_value_group != NULL )
729 {
730 libsigscan_byte_value_group_free(
731 &byte_value_group,
732 NULL );
733 }
734 if( signature != NULL )
735 {
736 libsigscan_signature_free(
737 &signature,
738 NULL );
739 }
740 return( 0 );
741 }
742
743 /* Tests the libsigscan_byte_value_group_get_number_of_signature_groups function
744 * Returns 1 if successful or 0 if not
745 */
sigscan_test_byte_value_group_get_number_of_signature_groups(void)746 int sigscan_test_byte_value_group_get_number_of_signature_groups(
747 void )
748 {
749 libcerror_error_t *error = NULL;
750 libsigscan_byte_value_group_t *byte_value_group = NULL;
751 libsigscan_signature_t *signature = NULL;
752 int number_of_signature_groups = 0;
753 int result = 0;
754
755 /* Initialize test
756 */
757 result = libsigscan_signature_initialize(
758 &signature,
759 &error );
760
761 SIGSCAN_TEST_ASSERT_EQUAL_INT(
762 "result",
763 result,
764 1 );
765
766 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
767 "signature",
768 signature );
769
770 SIGSCAN_TEST_ASSERT_IS_NULL(
771 "error",
772 error );
773
774 result = libsigscan_signature_set(
775 signature,
776 "identifier",
777 10,
778 0,
779 (uint8_t *) "pattern",
780 7,
781 LIBSIGSCAN_SIGNATURE_FLAG_OFFSET_RELATIVE_FROM_START,
782 &error );
783
784 SIGSCAN_TEST_ASSERT_EQUAL_INT(
785 "result",
786 result,
787 1 );
788
789 SIGSCAN_TEST_ASSERT_IS_NULL(
790 "error",
791 error );
792
793 result = libsigscan_byte_value_group_initialize(
794 &byte_value_group,
795 0,
796 &error );
797
798 SIGSCAN_TEST_ASSERT_EQUAL_INT(
799 "result",
800 result,
801 1 );
802
803 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
804 "byte_value_group",
805 byte_value_group );
806
807 SIGSCAN_TEST_ASSERT_IS_NULL(
808 "error",
809 error );
810
811 /* Test regular cases
812 */
813 result = libsigscan_byte_value_group_get_number_of_signature_groups(
814 byte_value_group,
815 &number_of_signature_groups,
816 &error );
817
818 SIGSCAN_TEST_ASSERT_EQUAL_INT(
819 "result",
820 result,
821 1 );
822
823 SIGSCAN_TEST_ASSERT_EQUAL_INT(
824 "number_of_signature_groups",
825 number_of_signature_groups,
826 0 );
827
828 SIGSCAN_TEST_ASSERT_IS_NULL(
829 "error",
830 error );
831
832 /* Initialize test
833 */
834 result = libsigscan_byte_value_group_insert_signature(
835 byte_value_group,
836 (uint8_t) 't',
837 signature,
838 &error );
839
840 SIGSCAN_TEST_ASSERT_EQUAL_INT(
841 "result",
842 result,
843 1 );
844
845 SIGSCAN_TEST_ASSERT_IS_NULL(
846 "error",
847 error );
848
849 /* Test regular cases
850 */
851 result = libsigscan_byte_value_group_get_number_of_signature_groups(
852 byte_value_group,
853 &number_of_signature_groups,
854 &error );
855
856 SIGSCAN_TEST_ASSERT_EQUAL_INT(
857 "result",
858 result,
859 1 );
860
861 SIGSCAN_TEST_ASSERT_EQUAL_INT(
862 "number_of_signature_groups",
863 number_of_signature_groups,
864 1 );
865
866 SIGSCAN_TEST_ASSERT_IS_NULL(
867 "error",
868 error );
869
870 /* Test error cases
871 */
872 result = libsigscan_byte_value_group_get_number_of_signature_groups(
873 NULL,
874 &number_of_signature_groups,
875 &error );
876
877 SIGSCAN_TEST_ASSERT_EQUAL_INT(
878 "result",
879 result,
880 -1 );
881
882 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
883 "error",
884 error );
885
886 libcerror_error_free(
887 &error );
888
889 result = libsigscan_byte_value_group_get_number_of_signature_groups(
890 byte_value_group,
891 NULL,
892 &error );
893
894 SIGSCAN_TEST_ASSERT_EQUAL_INT(
895 "result",
896 result,
897 -1 );
898
899 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
900 "error",
901 error );
902
903 libcerror_error_free(
904 &error );
905
906 /* Clean up
907 */
908 result = libsigscan_byte_value_group_free(
909 &byte_value_group,
910 &error );
911
912 SIGSCAN_TEST_ASSERT_EQUAL_INT(
913 "result",
914 result,
915 1 );
916
917 SIGSCAN_TEST_ASSERT_IS_NULL(
918 "byte_value_group",
919 byte_value_group );
920
921 SIGSCAN_TEST_ASSERT_IS_NULL(
922 "error",
923 error );
924
925 result = libsigscan_signature_free(
926 &signature,
927 &error );
928
929 SIGSCAN_TEST_ASSERT_EQUAL_INT(
930 "result",
931 result,
932 1 );
933
934 SIGSCAN_TEST_ASSERT_IS_NULL(
935 "signature",
936 signature );
937
938 SIGSCAN_TEST_ASSERT_IS_NULL(
939 "error",
940 error );
941
942 return( 1 );
943
944 on_error:
945 if( error != NULL )
946 {
947 libcerror_error_free(
948 &error );
949 }
950 if( byte_value_group != NULL )
951 {
952 libsigscan_byte_value_group_free(
953 &byte_value_group,
954 NULL );
955 }
956 if( signature != NULL )
957 {
958 libsigscan_signature_free(
959 &signature,
960 NULL );
961 }
962 return( 0 );
963 }
964
965 /* Tests the libsigscan_byte_value_group_get_signature_group_by_index function
966 * Returns 1 if successful or 0 if not
967 */
sigscan_test_byte_value_group_get_signature_group_by_index(void)968 int sigscan_test_byte_value_group_get_signature_group_by_index(
969 void )
970 {
971 libcerror_error_t *error = NULL;
972 libsigscan_byte_value_group_t *byte_value_group = NULL;
973 libsigscan_signature_t *signature = NULL;
974 libsigscan_signature_group_t *signature_group = 0;
975 int result = 0;
976
977 /* Initialize test
978 */
979 result = libsigscan_signature_initialize(
980 &signature,
981 &error );
982
983 SIGSCAN_TEST_ASSERT_EQUAL_INT(
984 "result",
985 result,
986 1 );
987
988 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
989 "signature",
990 signature );
991
992 SIGSCAN_TEST_ASSERT_IS_NULL(
993 "error",
994 error );
995
996 result = libsigscan_signature_set(
997 signature,
998 "identifier",
999 10,
1000 0,
1001 (uint8_t *) "pattern",
1002 7,
1003 LIBSIGSCAN_SIGNATURE_FLAG_OFFSET_RELATIVE_FROM_START,
1004 &error );
1005
1006 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1007 "result",
1008 result,
1009 1 );
1010
1011 SIGSCAN_TEST_ASSERT_IS_NULL(
1012 "error",
1013 error );
1014
1015 result = libsigscan_byte_value_group_initialize(
1016 &byte_value_group,
1017 0,
1018 &error );
1019
1020 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1021 "result",
1022 result,
1023 1 );
1024
1025 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
1026 "byte_value_group",
1027 byte_value_group );
1028
1029 SIGSCAN_TEST_ASSERT_IS_NULL(
1030 "error",
1031 error );
1032
1033 result = libsigscan_byte_value_group_insert_signature(
1034 byte_value_group,
1035 (uint8_t) 't',
1036 signature,
1037 &error );
1038
1039 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1040 "result",
1041 result,
1042 1 );
1043
1044 SIGSCAN_TEST_ASSERT_IS_NULL(
1045 "error",
1046 error );
1047
1048 /* Test regular cases
1049 */
1050 signature_group = NULL;
1051
1052 result = libsigscan_byte_value_group_get_signature_group_by_index(
1053 byte_value_group,
1054 0,
1055 &signature_group,
1056 &error );
1057
1058 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1059 "result",
1060 result,
1061 1 );
1062
1063 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
1064 "signature_group",
1065 signature_group );
1066
1067 SIGSCAN_TEST_ASSERT_IS_NULL(
1068 "error",
1069 error );
1070
1071 /* Test error cases
1072 */
1073 signature_group = NULL;
1074
1075 result = libsigscan_byte_value_group_get_signature_group_by_index(
1076 NULL,
1077 0,
1078 &signature_group,
1079 &error );
1080
1081 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1082 "result",
1083 result,
1084 -1 );
1085
1086 SIGSCAN_TEST_ASSERT_IS_NULL(
1087 "signature_group",
1088 signature_group );
1089
1090 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
1091 "error",
1092 error );
1093
1094 libcerror_error_free(
1095 &error );
1096
1097 result = libsigscan_byte_value_group_get_signature_group_by_index(
1098 byte_value_group,
1099 -1,
1100 &signature_group,
1101 &error );
1102
1103 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1104 "result",
1105 result,
1106 -1 );
1107
1108 SIGSCAN_TEST_ASSERT_IS_NULL(
1109 "signature_group",
1110 signature_group );
1111
1112 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
1113 "error",
1114 error );
1115
1116 libcerror_error_free(
1117 &error );
1118
1119 result = libsigscan_byte_value_group_get_signature_group_by_index(
1120 byte_value_group,
1121 0,
1122 NULL,
1123 &error );
1124
1125 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1126 "result",
1127 result,
1128 -1 );
1129
1130 SIGSCAN_TEST_ASSERT_IS_NULL(
1131 "signature_group",
1132 signature_group );
1133
1134 SIGSCAN_TEST_ASSERT_IS_NOT_NULL(
1135 "error",
1136 error );
1137
1138 libcerror_error_free(
1139 &error );
1140
1141 /* Clean up
1142 */
1143 result = libsigscan_byte_value_group_free(
1144 &byte_value_group,
1145 &error );
1146
1147 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1148 "result",
1149 result,
1150 1 );
1151
1152 SIGSCAN_TEST_ASSERT_IS_NULL(
1153 "byte_value_group",
1154 byte_value_group );
1155
1156 SIGSCAN_TEST_ASSERT_IS_NULL(
1157 "error",
1158 error );
1159
1160 result = libsigscan_signature_free(
1161 &signature,
1162 &error );
1163
1164 SIGSCAN_TEST_ASSERT_EQUAL_INT(
1165 "result",
1166 result,
1167 1 );
1168
1169 SIGSCAN_TEST_ASSERT_IS_NULL(
1170 "signature",
1171 signature );
1172
1173 SIGSCAN_TEST_ASSERT_IS_NULL(
1174 "error",
1175 error );
1176
1177 return( 1 );
1178
1179 on_error:
1180 if( error != NULL )
1181 {
1182 libcerror_error_free(
1183 &error );
1184 }
1185 if( byte_value_group != NULL )
1186 {
1187 libsigscan_byte_value_group_free(
1188 &byte_value_group,
1189 NULL );
1190 }
1191 if( signature != NULL )
1192 {
1193 libsigscan_signature_free(
1194 &signature,
1195 NULL );
1196 }
1197 return( 0 );
1198 }
1199
1200 #endif /* defined( __GNUC__ ) && !defined( LIBSIGSCAN_DLL_IMPORT ) */
1201
1202 /* The main program
1203 */
1204 #if defined( HAVE_WIDE_SYSTEM_CHARACTER )
wmain(int argc SIGSCAN_TEST_ATTRIBUTE_UNUSED,wchar_t * const argv[]SIGSCAN_TEST_ATTRIBUTE_UNUSED)1205 int wmain(
1206 int argc SIGSCAN_TEST_ATTRIBUTE_UNUSED,
1207 wchar_t * const argv[] SIGSCAN_TEST_ATTRIBUTE_UNUSED )
1208 #else
1209 int main(
1210 int argc SIGSCAN_TEST_ATTRIBUTE_UNUSED,
1211 char * const argv[] SIGSCAN_TEST_ATTRIBUTE_UNUSED )
1212 #endif
1213 {
1214 SIGSCAN_TEST_UNREFERENCED_PARAMETER( argc )
1215 SIGSCAN_TEST_UNREFERENCED_PARAMETER( argv )
1216
1217 #if defined( __GNUC__ ) && !defined( LIBSIGSCAN_DLL_IMPORT )
1218
1219 SIGSCAN_TEST_RUN(
1220 "libsigscan_byte_value_group_initialize",
1221 sigscan_test_byte_value_group_initialize );
1222
1223 SIGSCAN_TEST_RUN(
1224 "libsigscan_byte_value_group_free",
1225 sigscan_test_byte_value_group_free );
1226
1227 SIGSCAN_TEST_RUN(
1228 "libsigscan_byte_value_group_compare",
1229 sigscan_test_byte_value_group_compare );
1230
1231 SIGSCAN_TEST_RUN(
1232 "libsigscan_byte_value_group_get_pattern_offset",
1233 sigscan_test_byte_value_group_get_pattern_offset );
1234
1235 /* TODO: add tests for libsigscan_byte_value_group_get_signature_group */
1236
1237 SIGSCAN_TEST_RUN(
1238 "libsigscan_byte_value_group_insert_signature",
1239 sigscan_test_byte_value_group_insert_signature );
1240
1241 SIGSCAN_TEST_RUN(
1242 "libsigscan_byte_value_group_get_number_of_signature_groups",
1243 sigscan_test_byte_value_group_get_number_of_signature_groups );
1244
1245 SIGSCAN_TEST_RUN(
1246 "libsigscan_byte_value_group_get_signature_group_by_index",
1247 sigscan_test_byte_value_group_get_signature_group_by_index );
1248
1249 #endif /* defined( __GNUC__ ) && !defined( LIBSIGSCAN_DLL_IMPORT ) */
1250
1251 return( EXIT_SUCCESS );
1252
1253 on_error:
1254 return( EXIT_FAILURE );
1255 }
1256
1257