1 /*
2 * Library record_values type test program
3 *
4 * Copyright (C) 2011-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 "evtx_test_libcerror.h"
31 #include "evtx_test_libevtx.h"
32 #include "evtx_test_macros.h"
33 #include "evtx_test_memory.h"
34 #include "evtx_test_unused.h"
35
36 #include "../libevtx/libevtx_record_values.h"
37
38 #if defined( __GNUC__ ) && !defined( LIBEVTX_DLL_IMPORT )
39
40 /* Tests the libevtx_record_values_initialize function
41 * Returns 1 if successful or 0 if not
42 */
evtx_test_record_values_initialize(void)43 int evtx_test_record_values_initialize(
44 void )
45 {
46 libcerror_error_t *error = NULL;
47 libevtx_record_values_t *record_values = NULL;
48 int result = 0;
49
50 #if defined( HAVE_EVTX_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 = libevtx_record_values_initialize(
59 &record_values,
60 &error );
61
62 EVTX_TEST_ASSERT_EQUAL_INT(
63 "result",
64 result,
65 1 );
66
67 EVTX_TEST_ASSERT_IS_NOT_NULL(
68 "record_values",
69 record_values );
70
71 EVTX_TEST_ASSERT_IS_NULL(
72 "error",
73 error );
74
75 result = libevtx_record_values_free(
76 &record_values,
77 &error );
78
79 EVTX_TEST_ASSERT_EQUAL_INT(
80 "result",
81 result,
82 1 );
83
84 EVTX_TEST_ASSERT_IS_NULL(
85 "record_values",
86 record_values );
87
88 EVTX_TEST_ASSERT_IS_NULL(
89 "error",
90 error );
91
92 /* Test error cases
93 */
94 result = libevtx_record_values_initialize(
95 NULL,
96 &error );
97
98 EVTX_TEST_ASSERT_EQUAL_INT(
99 "result",
100 result,
101 -1 );
102
103 EVTX_TEST_ASSERT_IS_NOT_NULL(
104 "error",
105 error );
106
107 libcerror_error_free(
108 &error );
109
110 record_values = (libevtx_record_values_t *) 0x12345678UL;
111
112 result = libevtx_record_values_initialize(
113 &record_values,
114 &error );
115
116 EVTX_TEST_ASSERT_EQUAL_INT(
117 "result",
118 result,
119 -1 );
120
121 EVTX_TEST_ASSERT_IS_NOT_NULL(
122 "error",
123 error );
124
125 libcerror_error_free(
126 &error );
127
128 record_values = NULL;
129
130 #if defined( HAVE_EVTX_TEST_MEMORY )
131
132 for( test_number = 0;
133 test_number < number_of_malloc_fail_tests;
134 test_number++ )
135 {
136 /* Test libevtx_record_values_initialize with malloc failing
137 */
138 evtx_test_malloc_attempts_before_fail = test_number;
139
140 result = libevtx_record_values_initialize(
141 &record_values,
142 &error );
143
144 if( evtx_test_malloc_attempts_before_fail != -1 )
145 {
146 evtx_test_malloc_attempts_before_fail = -1;
147
148 if( record_values != NULL )
149 {
150 libevtx_record_values_free(
151 &record_values,
152 NULL );
153 }
154 }
155 else
156 {
157 EVTX_TEST_ASSERT_EQUAL_INT(
158 "result",
159 result,
160 -1 );
161
162 EVTX_TEST_ASSERT_IS_NULL(
163 "record_values",
164 record_values );
165
166 EVTX_TEST_ASSERT_IS_NOT_NULL(
167 "error",
168 error );
169
170 libcerror_error_free(
171 &error );
172 }
173 }
174 for( test_number = 0;
175 test_number < number_of_memset_fail_tests;
176 test_number++ )
177 {
178 /* Test libevtx_record_values_initialize with memset failing
179 */
180 evtx_test_memset_attempts_before_fail = test_number;
181
182 result = libevtx_record_values_initialize(
183 &record_values,
184 &error );
185
186 if( evtx_test_memset_attempts_before_fail != -1 )
187 {
188 evtx_test_memset_attempts_before_fail = -1;
189
190 if( record_values != NULL )
191 {
192 libevtx_record_values_free(
193 &record_values,
194 NULL );
195 }
196 }
197 else
198 {
199 EVTX_TEST_ASSERT_EQUAL_INT(
200 "result",
201 result,
202 -1 );
203
204 EVTX_TEST_ASSERT_IS_NULL(
205 "record_values",
206 record_values );
207
208 EVTX_TEST_ASSERT_IS_NOT_NULL(
209 "error",
210 error );
211
212 libcerror_error_free(
213 &error );
214 }
215 }
216 #endif /* defined( HAVE_EVTX_TEST_MEMORY ) */
217
218 return( 1 );
219
220 on_error:
221 if( error != NULL )
222 {
223 libcerror_error_free(
224 &error );
225 }
226 if( record_values != NULL )
227 {
228 libevtx_record_values_free(
229 &record_values,
230 NULL );
231 }
232 return( 0 );
233 }
234
235 /* Tests the libevtx_record_values_free function
236 * Returns 1 if successful or 0 if not
237 */
evtx_test_record_values_free(void)238 int evtx_test_record_values_free(
239 void )
240 {
241 libcerror_error_t *error = NULL;
242 int result = 0;
243
244 /* Test error cases
245 */
246 result = libevtx_record_values_free(
247 NULL,
248 &error );
249
250 EVTX_TEST_ASSERT_EQUAL_INT(
251 "result",
252 result,
253 -1 );
254
255 EVTX_TEST_ASSERT_IS_NOT_NULL(
256 "error",
257 error );
258
259 libcerror_error_free(
260 &error );
261
262 return( 1 );
263
264 on_error:
265 if( error != NULL )
266 {
267 libcerror_error_free(
268 &error );
269 }
270 return( 0 );
271 }
272
273 /* Tests the libevtx_record_values_clone function
274 * Returns 1 if successful or 0 if not
275 */
evtx_test_record_values_clone(void)276 int evtx_test_record_values_clone(
277 void )
278 {
279 libcerror_error_t *error = NULL;
280 libevtx_record_values_t *destination_record_values = NULL;
281 libevtx_record_values_t *source_record_values = NULL;
282 int result = 0;
283
284 /* Initialize test
285 */
286 result = libevtx_record_values_initialize(
287 &source_record_values,
288 &error );
289
290 EVTX_TEST_ASSERT_EQUAL_INT(
291 "result",
292 result,
293 1 );
294
295 EVTX_TEST_ASSERT_IS_NOT_NULL(
296 "source_record_values",
297 source_record_values );
298
299 EVTX_TEST_ASSERT_IS_NULL(
300 "error",
301 error );
302
303 /* Test regular cases
304 */
305 result = libevtx_record_values_clone(
306 &destination_record_values,
307 source_record_values,
308 &error );
309
310 EVTX_TEST_ASSERT_EQUAL_INT(
311 "result",
312 result,
313 1 );
314
315 EVTX_TEST_ASSERT_IS_NOT_NULL(
316 "destination_record_values",
317 destination_record_values );
318
319 EVTX_TEST_ASSERT_IS_NULL(
320 "error",
321 error );
322
323 result = libevtx_record_values_free(
324 &destination_record_values,
325 &error );
326
327 EVTX_TEST_ASSERT_EQUAL_INT(
328 "result",
329 result,
330 1 );
331
332 EVTX_TEST_ASSERT_IS_NULL(
333 "destination_record_values",
334 destination_record_values );
335
336 EVTX_TEST_ASSERT_IS_NULL(
337 "error",
338 error );
339
340 result = libevtx_record_values_clone(
341 &destination_record_values,
342 NULL,
343 &error );
344
345 EVTX_TEST_ASSERT_EQUAL_INT(
346 "result",
347 result,
348 1 );
349
350 EVTX_TEST_ASSERT_IS_NULL(
351 "destination_record_values",
352 destination_record_values );
353
354 EVTX_TEST_ASSERT_IS_NULL(
355 "error",
356 error );
357
358 /* Test error cases
359 */
360 result = libevtx_record_values_clone(
361 NULL,
362 source_record_values,
363 &error );
364
365 EVTX_TEST_ASSERT_EQUAL_INT(
366 "result",
367 result,
368 -1 );
369
370 EVTX_TEST_ASSERT_IS_NOT_NULL(
371 "error",
372 error );
373
374 libcerror_error_free(
375 &error );
376
377 /* Clean up
378 */
379 result = libevtx_record_values_free(
380 &source_record_values,
381 &error );
382
383 EVTX_TEST_ASSERT_EQUAL_INT(
384 "result",
385 result,
386 1 );
387
388 EVTX_TEST_ASSERT_IS_NULL(
389 "source_record_values",
390 source_record_values );
391
392 EVTX_TEST_ASSERT_IS_NULL(
393 "error",
394 error );
395
396 return( 1 );
397
398 on_error:
399 if( error != NULL )
400 {
401 libcerror_error_free(
402 &error );
403 }
404 if( destination_record_values != NULL )
405 {
406 libevtx_record_values_free(
407 &destination_record_values,
408 NULL );
409 }
410 if( source_record_values != NULL )
411 {
412 libevtx_record_values_free(
413 &source_record_values,
414 NULL );
415 }
416 return( 0 );
417 }
418
419 /* Tests the libevtx_record_values_get_event_identifier function
420 * Returns 1 if successful or 0 if not
421 */
evtx_test_record_values_get_event_identifier(void)422 int evtx_test_record_values_get_event_identifier(
423 void )
424 {
425 libcerror_error_t *error = NULL;
426 libevtx_record_values_t *record_values = NULL;
427 uint32_t event_identifier = 0;
428 int event_identifier_is_set = 0;
429 int result = 0;
430
431 /* Initialize test
432 */
433 result = libevtx_record_values_initialize(
434 &record_values,
435 &error );
436
437 EVTX_TEST_ASSERT_EQUAL_INT(
438 "result",
439 result,
440 1 );
441
442 EVTX_TEST_ASSERT_IS_NOT_NULL(
443 "record_values",
444 record_values );
445
446 EVTX_TEST_ASSERT_IS_NULL(
447 "error",
448 error );
449
450 /* Test regular cases
451 */
452 result = libevtx_record_values_get_event_identifier(
453 record_values,
454 &event_identifier,
455 &error );
456
457 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
458 "result",
459 result,
460 -1 );
461
462 EVTX_TEST_ASSERT_IS_NULL(
463 "error",
464 error );
465
466 event_identifier_is_set = result;
467
468 /* Test error cases
469 */
470 result = libevtx_record_values_get_event_identifier(
471 NULL,
472 &event_identifier,
473 &error );
474
475 EVTX_TEST_ASSERT_EQUAL_INT(
476 "result",
477 result,
478 -1 );
479
480 EVTX_TEST_ASSERT_IS_NOT_NULL(
481 "error",
482 error );
483
484 libcerror_error_free(
485 &error );
486
487 if( event_identifier_is_set != 0 )
488 {
489 result = libevtx_record_values_get_event_identifier(
490 record_values,
491 NULL,
492 &error );
493
494 EVTX_TEST_ASSERT_EQUAL_INT(
495 "result",
496 result,
497 -1 );
498
499 EVTX_TEST_ASSERT_IS_NOT_NULL(
500 "error",
501 error );
502
503 libcerror_error_free(
504 &error );
505 }
506 /* Clean up
507 */
508 result = libevtx_record_values_free(
509 &record_values,
510 &error );
511
512 EVTX_TEST_ASSERT_EQUAL_INT(
513 "result",
514 result,
515 1 );
516
517 EVTX_TEST_ASSERT_IS_NULL(
518 "record_values",
519 record_values );
520
521 EVTX_TEST_ASSERT_IS_NULL(
522 "error",
523 error );
524
525 return( 1 );
526
527 on_error:
528 if( error != NULL )
529 {
530 libcerror_error_free(
531 &error );
532 }
533 if( record_values != NULL )
534 {
535 libevtx_record_values_free(
536 &record_values,
537 NULL );
538 }
539 return( 0 );
540 }
541
542 /* Tests the libevtx_record_values_get_event_identifier_qualifiers function
543 * Returns 1 if successful or 0 if not
544 */
evtx_test_record_values_get_event_identifier_qualifiers(void)545 int evtx_test_record_values_get_event_identifier_qualifiers(
546 void )
547 {
548 libcerror_error_t *error = NULL;
549 libevtx_record_values_t *record_values = NULL;
550 uint32_t event_identifier_qualifiers = 0;
551 int event_identifier_qualifiers_is_set = 0;
552 int result = 0;
553
554 /* Initialize test
555 */
556 result = libevtx_record_values_initialize(
557 &record_values,
558 &error );
559
560 EVTX_TEST_ASSERT_EQUAL_INT(
561 "result",
562 result,
563 1 );
564
565 EVTX_TEST_ASSERT_IS_NOT_NULL(
566 "record_values",
567 record_values );
568
569 EVTX_TEST_ASSERT_IS_NULL(
570 "error",
571 error );
572
573 /* Test regular cases
574 */
575 result = libevtx_record_values_get_event_identifier_qualifiers(
576 record_values,
577 &event_identifier_qualifiers,
578 &error );
579
580 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
581 "result",
582 result,
583 -1 );
584
585 EVTX_TEST_ASSERT_IS_NULL(
586 "error",
587 error );
588
589 event_identifier_qualifiers_is_set = result;
590
591 /* Test error cases
592 */
593 result = libevtx_record_values_get_event_identifier_qualifiers(
594 NULL,
595 &event_identifier_qualifiers,
596 &error );
597
598 EVTX_TEST_ASSERT_EQUAL_INT(
599 "result",
600 result,
601 -1 );
602
603 EVTX_TEST_ASSERT_IS_NOT_NULL(
604 "error",
605 error );
606
607 libcerror_error_free(
608 &error );
609
610 if( event_identifier_qualifiers_is_set != 0 )
611 {
612 result = libevtx_record_values_get_event_identifier_qualifiers(
613 record_values,
614 NULL,
615 &error );
616
617 EVTX_TEST_ASSERT_EQUAL_INT(
618 "result",
619 result,
620 -1 );
621
622 EVTX_TEST_ASSERT_IS_NOT_NULL(
623 "error",
624 error );
625
626 libcerror_error_free(
627 &error );
628 }
629 /* Clean up
630 */
631 result = libevtx_record_values_free(
632 &record_values,
633 &error );
634
635 EVTX_TEST_ASSERT_EQUAL_INT(
636 "result",
637 result,
638 1 );
639
640 EVTX_TEST_ASSERT_IS_NULL(
641 "record_values",
642 record_values );
643
644 EVTX_TEST_ASSERT_IS_NULL(
645 "error",
646 error );
647
648 return( 1 );
649
650 on_error:
651 if( error != NULL )
652 {
653 libcerror_error_free(
654 &error );
655 }
656 if( record_values != NULL )
657 {
658 libevtx_record_values_free(
659 &record_values,
660 NULL );
661 }
662 return( 0 );
663 }
664
665 /* Tests the libevtx_record_values_get_event_level function
666 * Returns 1 if successful or 0 if not
667 */
evtx_test_record_values_get_event_level(void)668 int evtx_test_record_values_get_event_level(
669 void )
670 {
671 libcerror_error_t *error = NULL;
672 libevtx_record_values_t *record_values = NULL;
673 uint8_t event_level = 0;
674 int event_level_is_set = 0;
675 int result = 0;
676
677 /* Initialize test
678 */
679 result = libevtx_record_values_initialize(
680 &record_values,
681 &error );
682
683 EVTX_TEST_ASSERT_EQUAL_INT(
684 "result",
685 result,
686 1 );
687
688 EVTX_TEST_ASSERT_IS_NOT_NULL(
689 "record_values",
690 record_values );
691
692 EVTX_TEST_ASSERT_IS_NULL(
693 "error",
694 error );
695
696 /* Test regular cases
697 */
698 result = libevtx_record_values_get_event_level(
699 record_values,
700 &event_level,
701 &error );
702
703 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
704 "result",
705 result,
706 -1 );
707
708 EVTX_TEST_ASSERT_IS_NULL(
709 "error",
710 error );
711
712 event_level_is_set = result;
713
714 /* Test error cases
715 */
716 result = libevtx_record_values_get_event_level(
717 NULL,
718 &event_level,
719 &error );
720
721 EVTX_TEST_ASSERT_EQUAL_INT(
722 "result",
723 result,
724 -1 );
725
726 EVTX_TEST_ASSERT_IS_NOT_NULL(
727 "error",
728 error );
729
730 libcerror_error_free(
731 &error );
732
733 if( event_level_is_set != 0 )
734 {
735 result = libevtx_record_values_get_event_level(
736 record_values,
737 NULL,
738 &error );
739
740 EVTX_TEST_ASSERT_EQUAL_INT(
741 "result",
742 result,
743 -1 );
744
745 EVTX_TEST_ASSERT_IS_NOT_NULL(
746 "error",
747 error );
748
749 libcerror_error_free(
750 &error );
751 }
752 /* Clean up
753 */
754 result = libevtx_record_values_free(
755 &record_values,
756 &error );
757
758 EVTX_TEST_ASSERT_EQUAL_INT(
759 "result",
760 result,
761 1 );
762
763 EVTX_TEST_ASSERT_IS_NULL(
764 "record_values",
765 record_values );
766
767 EVTX_TEST_ASSERT_IS_NULL(
768 "error",
769 error );
770
771 return( 1 );
772
773 on_error:
774 if( error != NULL )
775 {
776 libcerror_error_free(
777 &error );
778 }
779 if( record_values != NULL )
780 {
781 libevtx_record_values_free(
782 &record_values,
783 NULL );
784 }
785 return( 0 );
786 }
787
788 /* Tests the libevtx_record_values_get_utf8_provider_identifier_size function
789 * Returns 1 if successful or 0 if not
790 */
evtx_test_record_values_get_utf8_provider_identifier_size(void)791 int evtx_test_record_values_get_utf8_provider_identifier_size(
792 void )
793 {
794 libcerror_error_t *error = NULL;
795 libevtx_record_values_t *record_values = NULL;
796 size_t utf8_provider_identifier_size = 0;
797 int result = 0;
798 int utf8_provider_identifier_size_is_set = 0;
799
800 /* Initialize test
801 */
802 result = libevtx_record_values_initialize(
803 &record_values,
804 &error );
805
806 EVTX_TEST_ASSERT_EQUAL_INT(
807 "result",
808 result,
809 1 );
810
811 EVTX_TEST_ASSERT_IS_NOT_NULL(
812 "record_values",
813 record_values );
814
815 EVTX_TEST_ASSERT_IS_NULL(
816 "error",
817 error );
818
819 /* Test regular cases
820 */
821 result = libevtx_record_values_get_utf8_provider_identifier_size(
822 record_values,
823 &utf8_provider_identifier_size,
824 &error );
825
826 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
827 "result",
828 result,
829 -1 );
830
831 EVTX_TEST_ASSERT_IS_NULL(
832 "error",
833 error );
834
835 utf8_provider_identifier_size_is_set = result;
836
837 /* Test error cases
838 */
839 result = libevtx_record_values_get_utf8_provider_identifier_size(
840 NULL,
841 &utf8_provider_identifier_size,
842 &error );
843
844 EVTX_TEST_ASSERT_EQUAL_INT(
845 "result",
846 result,
847 -1 );
848
849 EVTX_TEST_ASSERT_IS_NOT_NULL(
850 "error",
851 error );
852
853 libcerror_error_free(
854 &error );
855
856 if( utf8_provider_identifier_size_is_set != 0 )
857 {
858 result = libevtx_record_values_get_utf8_provider_identifier_size(
859 record_values,
860 NULL,
861 &error );
862
863 EVTX_TEST_ASSERT_EQUAL_INT(
864 "result",
865 result,
866 -1 );
867
868 EVTX_TEST_ASSERT_IS_NOT_NULL(
869 "error",
870 error );
871
872 libcerror_error_free(
873 &error );
874 }
875 /* Clean up
876 */
877 result = libevtx_record_values_free(
878 &record_values,
879 &error );
880
881 EVTX_TEST_ASSERT_EQUAL_INT(
882 "result",
883 result,
884 1 );
885
886 EVTX_TEST_ASSERT_IS_NULL(
887 "record_values",
888 record_values );
889
890 EVTX_TEST_ASSERT_IS_NULL(
891 "error",
892 error );
893
894 return( 1 );
895
896 on_error:
897 if( error != NULL )
898 {
899 libcerror_error_free(
900 &error );
901 }
902 if( record_values != NULL )
903 {
904 libevtx_record_values_free(
905 &record_values,
906 NULL );
907 }
908 return( 0 );
909 }
910
911 /* Tests the libevtx_record_values_get_utf8_provider_identifier function
912 * Returns 1 if successful or 0 if not
913 */
evtx_test_record_values_get_utf8_provider_identifier(void)914 int evtx_test_record_values_get_utf8_provider_identifier(
915 void )
916 {
917 uint8_t utf8_provider_identifier[ 512 ];
918
919 libcerror_error_t *error = NULL;
920 libevtx_record_values_t *record_values = NULL;
921 int result = 0;
922 int utf8_provider_identifier_is_set = 0;
923
924 /* Initialize test
925 */
926 result = libevtx_record_values_initialize(
927 &record_values,
928 &error );
929
930 EVTX_TEST_ASSERT_EQUAL_INT(
931 "result",
932 result,
933 1 );
934
935 EVTX_TEST_ASSERT_IS_NOT_NULL(
936 "record_values",
937 record_values );
938
939 EVTX_TEST_ASSERT_IS_NULL(
940 "error",
941 error );
942
943 /* Test regular cases
944 */
945 result = libevtx_record_values_get_utf8_provider_identifier(
946 record_values,
947 utf8_provider_identifier,
948 512,
949 &error );
950
951 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
952 "result",
953 result,
954 -1 );
955
956 EVTX_TEST_ASSERT_IS_NULL(
957 "error",
958 error );
959
960 utf8_provider_identifier_is_set = result;
961
962 /* Test error cases
963 */
964 result = libevtx_record_values_get_utf8_provider_identifier(
965 NULL,
966 utf8_provider_identifier,
967 512,
968 &error );
969
970 EVTX_TEST_ASSERT_EQUAL_INT(
971 "result",
972 result,
973 -1 );
974
975 EVTX_TEST_ASSERT_IS_NOT_NULL(
976 "error",
977 error );
978
979 libcerror_error_free(
980 &error );
981
982 if( utf8_provider_identifier_is_set != 0 )
983 {
984 result = libevtx_record_values_get_utf8_provider_identifier(
985 record_values,
986 NULL,
987 512,
988 &error );
989
990 EVTX_TEST_ASSERT_EQUAL_INT(
991 "result",
992 result,
993 -1 );
994
995 EVTX_TEST_ASSERT_IS_NOT_NULL(
996 "error",
997 error );
998
999 libcerror_error_free(
1000 &error );
1001
1002 result = libevtx_record_values_get_utf8_provider_identifier(
1003 record_values,
1004 utf8_provider_identifier,
1005 0,
1006 &error );
1007
1008 EVTX_TEST_ASSERT_EQUAL_INT(
1009 "result",
1010 result,
1011 -1 );
1012
1013 EVTX_TEST_ASSERT_IS_NOT_NULL(
1014 "error",
1015 error );
1016
1017 libcerror_error_free(
1018 &error );
1019
1020 result = libevtx_record_values_get_utf8_provider_identifier(
1021 record_values,
1022 utf8_provider_identifier,
1023 (size_t) SSIZE_MAX + 1,
1024 &error );
1025
1026 EVTX_TEST_ASSERT_EQUAL_INT(
1027 "result",
1028 result,
1029 -1 );
1030
1031 EVTX_TEST_ASSERT_IS_NOT_NULL(
1032 "error",
1033 error );
1034
1035 libcerror_error_free(
1036 &error );
1037 }
1038 /* Clean up
1039 */
1040 result = libevtx_record_values_free(
1041 &record_values,
1042 &error );
1043
1044 EVTX_TEST_ASSERT_EQUAL_INT(
1045 "result",
1046 result,
1047 1 );
1048
1049 EVTX_TEST_ASSERT_IS_NULL(
1050 "record_values",
1051 record_values );
1052
1053 EVTX_TEST_ASSERT_IS_NULL(
1054 "error",
1055 error );
1056
1057 return( 1 );
1058
1059 on_error:
1060 if( error != NULL )
1061 {
1062 libcerror_error_free(
1063 &error );
1064 }
1065 if( record_values != NULL )
1066 {
1067 libevtx_record_values_free(
1068 &record_values,
1069 NULL );
1070 }
1071 return( 0 );
1072 }
1073
1074 /* Tests the libevtx_record_values_get_utf16_provider_identifier_size function
1075 * Returns 1 if successful or 0 if not
1076 */
evtx_test_record_values_get_utf16_provider_identifier_size(void)1077 int evtx_test_record_values_get_utf16_provider_identifier_size(
1078 void )
1079 {
1080 libcerror_error_t *error = NULL;
1081 libevtx_record_values_t *record_values = NULL;
1082 size_t utf16_provider_identifier_size = 0;
1083 int result = 0;
1084 int utf16_provider_identifier_size_is_set = 0;
1085
1086 /* Initialize test
1087 */
1088 result = libevtx_record_values_initialize(
1089 &record_values,
1090 &error );
1091
1092 EVTX_TEST_ASSERT_EQUAL_INT(
1093 "result",
1094 result,
1095 1 );
1096
1097 EVTX_TEST_ASSERT_IS_NOT_NULL(
1098 "record_values",
1099 record_values );
1100
1101 EVTX_TEST_ASSERT_IS_NULL(
1102 "error",
1103 error );
1104
1105 /* Test regular cases
1106 */
1107 result = libevtx_record_values_get_utf16_provider_identifier_size(
1108 record_values,
1109 &utf16_provider_identifier_size,
1110 &error );
1111
1112 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
1113 "result",
1114 result,
1115 -1 );
1116
1117 EVTX_TEST_ASSERT_IS_NULL(
1118 "error",
1119 error );
1120
1121 utf16_provider_identifier_size_is_set = result;
1122
1123 /* Test error cases
1124 */
1125 result = libevtx_record_values_get_utf16_provider_identifier_size(
1126 NULL,
1127 &utf16_provider_identifier_size,
1128 &error );
1129
1130 EVTX_TEST_ASSERT_EQUAL_INT(
1131 "result",
1132 result,
1133 -1 );
1134
1135 EVTX_TEST_ASSERT_IS_NOT_NULL(
1136 "error",
1137 error );
1138
1139 libcerror_error_free(
1140 &error );
1141
1142 if( utf16_provider_identifier_size_is_set != 0 )
1143 {
1144 result = libevtx_record_values_get_utf16_provider_identifier_size(
1145 record_values,
1146 NULL,
1147 &error );
1148
1149 EVTX_TEST_ASSERT_EQUAL_INT(
1150 "result",
1151 result,
1152 -1 );
1153
1154 EVTX_TEST_ASSERT_IS_NOT_NULL(
1155 "error",
1156 error );
1157
1158 libcerror_error_free(
1159 &error );
1160 }
1161 /* Clean up
1162 */
1163 result = libevtx_record_values_free(
1164 &record_values,
1165 &error );
1166
1167 EVTX_TEST_ASSERT_EQUAL_INT(
1168 "result",
1169 result,
1170 1 );
1171
1172 EVTX_TEST_ASSERT_IS_NULL(
1173 "record_values",
1174 record_values );
1175
1176 EVTX_TEST_ASSERT_IS_NULL(
1177 "error",
1178 error );
1179
1180 return( 1 );
1181
1182 on_error:
1183 if( error != NULL )
1184 {
1185 libcerror_error_free(
1186 &error );
1187 }
1188 if( record_values != NULL )
1189 {
1190 libevtx_record_values_free(
1191 &record_values,
1192 NULL );
1193 }
1194 return( 0 );
1195 }
1196
1197 /* Tests the libevtx_record_values_get_utf16_provider_identifier function
1198 * Returns 1 if successful or 0 if not
1199 */
evtx_test_record_values_get_utf16_provider_identifier(void)1200 int evtx_test_record_values_get_utf16_provider_identifier(
1201 void )
1202 {
1203 uint16_t utf16_provider_identifier[ 512 ];
1204
1205 libcerror_error_t *error = NULL;
1206 libevtx_record_values_t *record_values = NULL;
1207 int result = 0;
1208 int utf16_provider_identifier_is_set = 0;
1209
1210 /* Initialize test
1211 */
1212 result = libevtx_record_values_initialize(
1213 &record_values,
1214 &error );
1215
1216 EVTX_TEST_ASSERT_EQUAL_INT(
1217 "result",
1218 result,
1219 1 );
1220
1221 EVTX_TEST_ASSERT_IS_NOT_NULL(
1222 "record_values",
1223 record_values );
1224
1225 EVTX_TEST_ASSERT_IS_NULL(
1226 "error",
1227 error );
1228
1229 /* Test regular cases
1230 */
1231 result = libevtx_record_values_get_utf16_provider_identifier(
1232 record_values,
1233 utf16_provider_identifier,
1234 512,
1235 &error );
1236
1237 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
1238 "result",
1239 result,
1240 -1 );
1241
1242 EVTX_TEST_ASSERT_IS_NULL(
1243 "error",
1244 error );
1245
1246 utf16_provider_identifier_is_set = result;
1247
1248 /* Test error cases
1249 */
1250 result = libevtx_record_values_get_utf16_provider_identifier(
1251 NULL,
1252 utf16_provider_identifier,
1253 512,
1254 &error );
1255
1256 EVTX_TEST_ASSERT_EQUAL_INT(
1257 "result",
1258 result,
1259 -1 );
1260
1261 EVTX_TEST_ASSERT_IS_NOT_NULL(
1262 "error",
1263 error );
1264
1265 libcerror_error_free(
1266 &error );
1267
1268 if( utf16_provider_identifier_is_set != 0 )
1269 {
1270 result = libevtx_record_values_get_utf16_provider_identifier(
1271 record_values,
1272 NULL,
1273 512,
1274 &error );
1275
1276 EVTX_TEST_ASSERT_EQUAL_INT(
1277 "result",
1278 result,
1279 -1 );
1280
1281 EVTX_TEST_ASSERT_IS_NOT_NULL(
1282 "error",
1283 error );
1284
1285 libcerror_error_free(
1286 &error );
1287
1288 result = libevtx_record_values_get_utf16_provider_identifier(
1289 record_values,
1290 utf16_provider_identifier,
1291 0,
1292 &error );
1293
1294 EVTX_TEST_ASSERT_EQUAL_INT(
1295 "result",
1296 result,
1297 -1 );
1298
1299 EVTX_TEST_ASSERT_IS_NOT_NULL(
1300 "error",
1301 error );
1302
1303 libcerror_error_free(
1304 &error );
1305
1306 result = libevtx_record_values_get_utf16_provider_identifier(
1307 record_values,
1308 utf16_provider_identifier,
1309 (size_t) SSIZE_MAX + 1,
1310 &error );
1311
1312 EVTX_TEST_ASSERT_EQUAL_INT(
1313 "result",
1314 result,
1315 -1 );
1316
1317 EVTX_TEST_ASSERT_IS_NOT_NULL(
1318 "error",
1319 error );
1320
1321 libcerror_error_free(
1322 &error );
1323 }
1324 /* Clean up
1325 */
1326 result = libevtx_record_values_free(
1327 &record_values,
1328 &error );
1329
1330 EVTX_TEST_ASSERT_EQUAL_INT(
1331 "result",
1332 result,
1333 1 );
1334
1335 EVTX_TEST_ASSERT_IS_NULL(
1336 "record_values",
1337 record_values );
1338
1339 EVTX_TEST_ASSERT_IS_NULL(
1340 "error",
1341 error );
1342
1343 return( 1 );
1344
1345 on_error:
1346 if( error != NULL )
1347 {
1348 libcerror_error_free(
1349 &error );
1350 }
1351 if( record_values != NULL )
1352 {
1353 libevtx_record_values_free(
1354 &record_values,
1355 NULL );
1356 }
1357 return( 0 );
1358 }
1359
1360 /* Tests the libevtx_record_values_get_utf8_source_name_size function
1361 * Returns 1 if successful or 0 if not
1362 */
evtx_test_record_values_get_utf8_source_name_size(void)1363 int evtx_test_record_values_get_utf8_source_name_size(
1364 void )
1365 {
1366 libcerror_error_t *error = NULL;
1367 libevtx_record_values_t *record_values = NULL;
1368 size_t utf8_source_name_size = 0;
1369 int result = 0;
1370 int utf8_source_name_size_is_set = 0;
1371
1372 /* Initialize test
1373 */
1374 result = libevtx_record_values_initialize(
1375 &record_values,
1376 &error );
1377
1378 EVTX_TEST_ASSERT_EQUAL_INT(
1379 "result",
1380 result,
1381 1 );
1382
1383 EVTX_TEST_ASSERT_IS_NOT_NULL(
1384 "record_values",
1385 record_values );
1386
1387 EVTX_TEST_ASSERT_IS_NULL(
1388 "error",
1389 error );
1390
1391 /* Test regular cases
1392 */
1393 result = libevtx_record_values_get_utf8_source_name_size(
1394 record_values,
1395 &utf8_source_name_size,
1396 &error );
1397
1398 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
1399 "result",
1400 result,
1401 -1 );
1402
1403 EVTX_TEST_ASSERT_IS_NULL(
1404 "error",
1405 error );
1406
1407 utf8_source_name_size_is_set = result;
1408
1409 /* Test error cases
1410 */
1411 result = libevtx_record_values_get_utf8_source_name_size(
1412 NULL,
1413 &utf8_source_name_size,
1414 &error );
1415
1416 EVTX_TEST_ASSERT_EQUAL_INT(
1417 "result",
1418 result,
1419 -1 );
1420
1421 EVTX_TEST_ASSERT_IS_NOT_NULL(
1422 "error",
1423 error );
1424
1425 libcerror_error_free(
1426 &error );
1427
1428 if( utf8_source_name_size_is_set != 0 )
1429 {
1430 result = libevtx_record_values_get_utf8_source_name_size(
1431 record_values,
1432 NULL,
1433 &error );
1434
1435 EVTX_TEST_ASSERT_EQUAL_INT(
1436 "result",
1437 result,
1438 -1 );
1439
1440 EVTX_TEST_ASSERT_IS_NOT_NULL(
1441 "error",
1442 error );
1443
1444 libcerror_error_free(
1445 &error );
1446 }
1447 /* Clean up
1448 */
1449 result = libevtx_record_values_free(
1450 &record_values,
1451 &error );
1452
1453 EVTX_TEST_ASSERT_EQUAL_INT(
1454 "result",
1455 result,
1456 1 );
1457
1458 EVTX_TEST_ASSERT_IS_NULL(
1459 "record_values",
1460 record_values );
1461
1462 EVTX_TEST_ASSERT_IS_NULL(
1463 "error",
1464 error );
1465
1466 return( 1 );
1467
1468 on_error:
1469 if( error != NULL )
1470 {
1471 libcerror_error_free(
1472 &error );
1473 }
1474 if( record_values != NULL )
1475 {
1476 libevtx_record_values_free(
1477 &record_values,
1478 NULL );
1479 }
1480 return( 0 );
1481 }
1482
1483 /* Tests the libevtx_record_values_get_utf8_source_name function
1484 * Returns 1 if successful or 0 if not
1485 */
evtx_test_record_values_get_utf8_source_name(void)1486 int evtx_test_record_values_get_utf8_source_name(
1487 void )
1488 {
1489 uint8_t utf8_source_name[ 512 ];
1490
1491 libcerror_error_t *error = NULL;
1492 libevtx_record_values_t *record_values = NULL;
1493 int result = 0;
1494 int utf8_source_name_is_set = 0;
1495
1496 /* Initialize test
1497 */
1498 result = libevtx_record_values_initialize(
1499 &record_values,
1500 &error );
1501
1502 EVTX_TEST_ASSERT_EQUAL_INT(
1503 "result",
1504 result,
1505 1 );
1506
1507 EVTX_TEST_ASSERT_IS_NOT_NULL(
1508 "record_values",
1509 record_values );
1510
1511 EVTX_TEST_ASSERT_IS_NULL(
1512 "error",
1513 error );
1514
1515 /* Test regular cases
1516 */
1517 result = libevtx_record_values_get_utf8_source_name(
1518 record_values,
1519 utf8_source_name,
1520 512,
1521 &error );
1522
1523 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
1524 "result",
1525 result,
1526 -1 );
1527
1528 EVTX_TEST_ASSERT_IS_NULL(
1529 "error",
1530 error );
1531
1532 utf8_source_name_is_set = result;
1533
1534 /* Test error cases
1535 */
1536 result = libevtx_record_values_get_utf8_source_name(
1537 NULL,
1538 utf8_source_name,
1539 512,
1540 &error );
1541
1542 EVTX_TEST_ASSERT_EQUAL_INT(
1543 "result",
1544 result,
1545 -1 );
1546
1547 EVTX_TEST_ASSERT_IS_NOT_NULL(
1548 "error",
1549 error );
1550
1551 libcerror_error_free(
1552 &error );
1553
1554 if( utf8_source_name_is_set != 0 )
1555 {
1556 result = libevtx_record_values_get_utf8_source_name(
1557 record_values,
1558 NULL,
1559 512,
1560 &error );
1561
1562 EVTX_TEST_ASSERT_EQUAL_INT(
1563 "result",
1564 result,
1565 -1 );
1566
1567 EVTX_TEST_ASSERT_IS_NOT_NULL(
1568 "error",
1569 error );
1570
1571 libcerror_error_free(
1572 &error );
1573
1574 result = libevtx_record_values_get_utf8_source_name(
1575 record_values,
1576 utf8_source_name,
1577 0,
1578 &error );
1579
1580 EVTX_TEST_ASSERT_EQUAL_INT(
1581 "result",
1582 result,
1583 -1 );
1584
1585 EVTX_TEST_ASSERT_IS_NOT_NULL(
1586 "error",
1587 error );
1588
1589 libcerror_error_free(
1590 &error );
1591
1592 result = libevtx_record_values_get_utf8_source_name(
1593 record_values,
1594 utf8_source_name,
1595 (size_t) SSIZE_MAX + 1,
1596 &error );
1597
1598 EVTX_TEST_ASSERT_EQUAL_INT(
1599 "result",
1600 result,
1601 -1 );
1602
1603 EVTX_TEST_ASSERT_IS_NOT_NULL(
1604 "error",
1605 error );
1606
1607 libcerror_error_free(
1608 &error );
1609 }
1610 /* Clean up
1611 */
1612 result = libevtx_record_values_free(
1613 &record_values,
1614 &error );
1615
1616 EVTX_TEST_ASSERT_EQUAL_INT(
1617 "result",
1618 result,
1619 1 );
1620
1621 EVTX_TEST_ASSERT_IS_NULL(
1622 "record_values",
1623 record_values );
1624
1625 EVTX_TEST_ASSERT_IS_NULL(
1626 "error",
1627 error );
1628
1629 return( 1 );
1630
1631 on_error:
1632 if( error != NULL )
1633 {
1634 libcerror_error_free(
1635 &error );
1636 }
1637 if( record_values != NULL )
1638 {
1639 libevtx_record_values_free(
1640 &record_values,
1641 NULL );
1642 }
1643 return( 0 );
1644 }
1645
1646 /* Tests the libevtx_record_values_get_utf16_source_name_size function
1647 * Returns 1 if successful or 0 if not
1648 */
evtx_test_record_values_get_utf16_source_name_size(void)1649 int evtx_test_record_values_get_utf16_source_name_size(
1650 void )
1651 {
1652 libcerror_error_t *error = NULL;
1653 libevtx_record_values_t *record_values = NULL;
1654 size_t utf16_source_name_size = 0;
1655 int result = 0;
1656 int utf16_source_name_size_is_set = 0;
1657
1658 /* Initialize test
1659 */
1660 result = libevtx_record_values_initialize(
1661 &record_values,
1662 &error );
1663
1664 EVTX_TEST_ASSERT_EQUAL_INT(
1665 "result",
1666 result,
1667 1 );
1668
1669 EVTX_TEST_ASSERT_IS_NOT_NULL(
1670 "record_values",
1671 record_values );
1672
1673 EVTX_TEST_ASSERT_IS_NULL(
1674 "error",
1675 error );
1676
1677 /* Test regular cases
1678 */
1679 result = libevtx_record_values_get_utf16_source_name_size(
1680 record_values,
1681 &utf16_source_name_size,
1682 &error );
1683
1684 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
1685 "result",
1686 result,
1687 -1 );
1688
1689 EVTX_TEST_ASSERT_IS_NULL(
1690 "error",
1691 error );
1692
1693 utf16_source_name_size_is_set = result;
1694
1695 /* Test error cases
1696 */
1697 result = libevtx_record_values_get_utf16_source_name_size(
1698 NULL,
1699 &utf16_source_name_size,
1700 &error );
1701
1702 EVTX_TEST_ASSERT_EQUAL_INT(
1703 "result",
1704 result,
1705 -1 );
1706
1707 EVTX_TEST_ASSERT_IS_NOT_NULL(
1708 "error",
1709 error );
1710
1711 libcerror_error_free(
1712 &error );
1713
1714 if( utf16_source_name_size_is_set != 0 )
1715 {
1716 result = libevtx_record_values_get_utf16_source_name_size(
1717 record_values,
1718 NULL,
1719 &error );
1720
1721 EVTX_TEST_ASSERT_EQUAL_INT(
1722 "result",
1723 result,
1724 -1 );
1725
1726 EVTX_TEST_ASSERT_IS_NOT_NULL(
1727 "error",
1728 error );
1729
1730 libcerror_error_free(
1731 &error );
1732 }
1733 /* Clean up
1734 */
1735 result = libevtx_record_values_free(
1736 &record_values,
1737 &error );
1738
1739 EVTX_TEST_ASSERT_EQUAL_INT(
1740 "result",
1741 result,
1742 1 );
1743
1744 EVTX_TEST_ASSERT_IS_NULL(
1745 "record_values",
1746 record_values );
1747
1748 EVTX_TEST_ASSERT_IS_NULL(
1749 "error",
1750 error );
1751
1752 return( 1 );
1753
1754 on_error:
1755 if( error != NULL )
1756 {
1757 libcerror_error_free(
1758 &error );
1759 }
1760 if( record_values != NULL )
1761 {
1762 libevtx_record_values_free(
1763 &record_values,
1764 NULL );
1765 }
1766 return( 0 );
1767 }
1768
1769 /* Tests the libevtx_record_values_get_utf16_source_name function
1770 * Returns 1 if successful or 0 if not
1771 */
evtx_test_record_values_get_utf16_source_name(void)1772 int evtx_test_record_values_get_utf16_source_name(
1773 void )
1774 {
1775 uint16_t utf16_source_name[ 512 ];
1776
1777 libcerror_error_t *error = NULL;
1778 libevtx_record_values_t *record_values = NULL;
1779 int result = 0;
1780 int utf16_source_name_is_set = 0;
1781
1782 /* Initialize test
1783 */
1784 result = libevtx_record_values_initialize(
1785 &record_values,
1786 &error );
1787
1788 EVTX_TEST_ASSERT_EQUAL_INT(
1789 "result",
1790 result,
1791 1 );
1792
1793 EVTX_TEST_ASSERT_IS_NOT_NULL(
1794 "record_values",
1795 record_values );
1796
1797 EVTX_TEST_ASSERT_IS_NULL(
1798 "error",
1799 error );
1800
1801 /* Test regular cases
1802 */
1803 result = libevtx_record_values_get_utf16_source_name(
1804 record_values,
1805 utf16_source_name,
1806 512,
1807 &error );
1808
1809 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
1810 "result",
1811 result,
1812 -1 );
1813
1814 EVTX_TEST_ASSERT_IS_NULL(
1815 "error",
1816 error );
1817
1818 utf16_source_name_is_set = result;
1819
1820 /* Test error cases
1821 */
1822 result = libevtx_record_values_get_utf16_source_name(
1823 NULL,
1824 utf16_source_name,
1825 512,
1826 &error );
1827
1828 EVTX_TEST_ASSERT_EQUAL_INT(
1829 "result",
1830 result,
1831 -1 );
1832
1833 EVTX_TEST_ASSERT_IS_NOT_NULL(
1834 "error",
1835 error );
1836
1837 libcerror_error_free(
1838 &error );
1839
1840 if( utf16_source_name_is_set != 0 )
1841 {
1842 result = libevtx_record_values_get_utf16_source_name(
1843 record_values,
1844 NULL,
1845 512,
1846 &error );
1847
1848 EVTX_TEST_ASSERT_EQUAL_INT(
1849 "result",
1850 result,
1851 -1 );
1852
1853 EVTX_TEST_ASSERT_IS_NOT_NULL(
1854 "error",
1855 error );
1856
1857 libcerror_error_free(
1858 &error );
1859
1860 result = libevtx_record_values_get_utf16_source_name(
1861 record_values,
1862 utf16_source_name,
1863 0,
1864 &error );
1865
1866 EVTX_TEST_ASSERT_EQUAL_INT(
1867 "result",
1868 result,
1869 -1 );
1870
1871 EVTX_TEST_ASSERT_IS_NOT_NULL(
1872 "error",
1873 error );
1874
1875 libcerror_error_free(
1876 &error );
1877
1878 result = libevtx_record_values_get_utf16_source_name(
1879 record_values,
1880 utf16_source_name,
1881 (size_t) SSIZE_MAX + 1,
1882 &error );
1883
1884 EVTX_TEST_ASSERT_EQUAL_INT(
1885 "result",
1886 result,
1887 -1 );
1888
1889 EVTX_TEST_ASSERT_IS_NOT_NULL(
1890 "error",
1891 error );
1892
1893 libcerror_error_free(
1894 &error );
1895 }
1896 /* Clean up
1897 */
1898 result = libevtx_record_values_free(
1899 &record_values,
1900 &error );
1901
1902 EVTX_TEST_ASSERT_EQUAL_INT(
1903 "result",
1904 result,
1905 1 );
1906
1907 EVTX_TEST_ASSERT_IS_NULL(
1908 "record_values",
1909 record_values );
1910
1911 EVTX_TEST_ASSERT_IS_NULL(
1912 "error",
1913 error );
1914
1915 return( 1 );
1916
1917 on_error:
1918 if( error != NULL )
1919 {
1920 libcerror_error_free(
1921 &error );
1922 }
1923 if( record_values != NULL )
1924 {
1925 libevtx_record_values_free(
1926 &record_values,
1927 NULL );
1928 }
1929 return( 0 );
1930 }
1931
1932 /* Tests the libevtx_record_values_get_utf8_computer_name_size function
1933 * Returns 1 if successful or 0 if not
1934 */
evtx_test_record_values_get_utf8_computer_name_size(void)1935 int evtx_test_record_values_get_utf8_computer_name_size(
1936 void )
1937 {
1938 libcerror_error_t *error = NULL;
1939 libevtx_record_values_t *record_values = NULL;
1940 size_t utf8_computer_name_size = 0;
1941 int result = 0;
1942 int utf8_computer_name_size_is_set = 0;
1943
1944 /* Initialize test
1945 */
1946 result = libevtx_record_values_initialize(
1947 &record_values,
1948 &error );
1949
1950 EVTX_TEST_ASSERT_EQUAL_INT(
1951 "result",
1952 result,
1953 1 );
1954
1955 EVTX_TEST_ASSERT_IS_NOT_NULL(
1956 "record_values",
1957 record_values );
1958
1959 EVTX_TEST_ASSERT_IS_NULL(
1960 "error",
1961 error );
1962
1963 /* Test regular cases
1964 */
1965 result = libevtx_record_values_get_utf8_computer_name_size(
1966 record_values,
1967 &utf8_computer_name_size,
1968 &error );
1969
1970 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
1971 "result",
1972 result,
1973 -1 );
1974
1975 EVTX_TEST_ASSERT_IS_NULL(
1976 "error",
1977 error );
1978
1979 utf8_computer_name_size_is_set = result;
1980
1981 /* Test error cases
1982 */
1983 result = libevtx_record_values_get_utf8_computer_name_size(
1984 NULL,
1985 &utf8_computer_name_size,
1986 &error );
1987
1988 EVTX_TEST_ASSERT_EQUAL_INT(
1989 "result",
1990 result,
1991 -1 );
1992
1993 EVTX_TEST_ASSERT_IS_NOT_NULL(
1994 "error",
1995 error );
1996
1997 libcerror_error_free(
1998 &error );
1999
2000 if( utf8_computer_name_size_is_set != 0 )
2001 {
2002 result = libevtx_record_values_get_utf8_computer_name_size(
2003 record_values,
2004 NULL,
2005 &error );
2006
2007 EVTX_TEST_ASSERT_EQUAL_INT(
2008 "result",
2009 result,
2010 -1 );
2011
2012 EVTX_TEST_ASSERT_IS_NOT_NULL(
2013 "error",
2014 error );
2015
2016 libcerror_error_free(
2017 &error );
2018 }
2019 /* Clean up
2020 */
2021 result = libevtx_record_values_free(
2022 &record_values,
2023 &error );
2024
2025 EVTX_TEST_ASSERT_EQUAL_INT(
2026 "result",
2027 result,
2028 1 );
2029
2030 EVTX_TEST_ASSERT_IS_NULL(
2031 "record_values",
2032 record_values );
2033
2034 EVTX_TEST_ASSERT_IS_NULL(
2035 "error",
2036 error );
2037
2038 return( 1 );
2039
2040 on_error:
2041 if( error != NULL )
2042 {
2043 libcerror_error_free(
2044 &error );
2045 }
2046 if( record_values != NULL )
2047 {
2048 libevtx_record_values_free(
2049 &record_values,
2050 NULL );
2051 }
2052 return( 0 );
2053 }
2054
2055 /* Tests the libevtx_record_values_get_utf8_computer_name function
2056 * Returns 1 if successful or 0 if not
2057 */
evtx_test_record_values_get_utf8_computer_name(void)2058 int evtx_test_record_values_get_utf8_computer_name(
2059 void )
2060 {
2061 uint8_t utf8_computer_name[ 512 ];
2062
2063 libcerror_error_t *error = NULL;
2064 libevtx_record_values_t *record_values = NULL;
2065 int result = 0;
2066 int utf8_computer_name_is_set = 0;
2067
2068 /* Initialize test
2069 */
2070 result = libevtx_record_values_initialize(
2071 &record_values,
2072 &error );
2073
2074 EVTX_TEST_ASSERT_EQUAL_INT(
2075 "result",
2076 result,
2077 1 );
2078
2079 EVTX_TEST_ASSERT_IS_NOT_NULL(
2080 "record_values",
2081 record_values );
2082
2083 EVTX_TEST_ASSERT_IS_NULL(
2084 "error",
2085 error );
2086
2087 /* Test regular cases
2088 */
2089 result = libevtx_record_values_get_utf8_computer_name(
2090 record_values,
2091 utf8_computer_name,
2092 512,
2093 &error );
2094
2095 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
2096 "result",
2097 result,
2098 -1 );
2099
2100 EVTX_TEST_ASSERT_IS_NULL(
2101 "error",
2102 error );
2103
2104 utf8_computer_name_is_set = result;
2105
2106 /* Test error cases
2107 */
2108 result = libevtx_record_values_get_utf8_computer_name(
2109 NULL,
2110 utf8_computer_name,
2111 512,
2112 &error );
2113
2114 EVTX_TEST_ASSERT_EQUAL_INT(
2115 "result",
2116 result,
2117 -1 );
2118
2119 EVTX_TEST_ASSERT_IS_NOT_NULL(
2120 "error",
2121 error );
2122
2123 libcerror_error_free(
2124 &error );
2125
2126 if( utf8_computer_name_is_set != 0 )
2127 {
2128 result = libevtx_record_values_get_utf8_computer_name(
2129 record_values,
2130 NULL,
2131 512,
2132 &error );
2133
2134 EVTX_TEST_ASSERT_EQUAL_INT(
2135 "result",
2136 result,
2137 -1 );
2138
2139 EVTX_TEST_ASSERT_IS_NOT_NULL(
2140 "error",
2141 error );
2142
2143 libcerror_error_free(
2144 &error );
2145
2146 result = libevtx_record_values_get_utf8_computer_name(
2147 record_values,
2148 utf8_computer_name,
2149 0,
2150 &error );
2151
2152 EVTX_TEST_ASSERT_EQUAL_INT(
2153 "result",
2154 result,
2155 -1 );
2156
2157 EVTX_TEST_ASSERT_IS_NOT_NULL(
2158 "error",
2159 error );
2160
2161 libcerror_error_free(
2162 &error );
2163
2164 result = libevtx_record_values_get_utf8_computer_name(
2165 record_values,
2166 utf8_computer_name,
2167 (size_t) SSIZE_MAX + 1,
2168 &error );
2169
2170 EVTX_TEST_ASSERT_EQUAL_INT(
2171 "result",
2172 result,
2173 -1 );
2174
2175 EVTX_TEST_ASSERT_IS_NOT_NULL(
2176 "error",
2177 error );
2178
2179 libcerror_error_free(
2180 &error );
2181 }
2182 /* Clean up
2183 */
2184 result = libevtx_record_values_free(
2185 &record_values,
2186 &error );
2187
2188 EVTX_TEST_ASSERT_EQUAL_INT(
2189 "result",
2190 result,
2191 1 );
2192
2193 EVTX_TEST_ASSERT_IS_NULL(
2194 "record_values",
2195 record_values );
2196
2197 EVTX_TEST_ASSERT_IS_NULL(
2198 "error",
2199 error );
2200
2201 return( 1 );
2202
2203 on_error:
2204 if( error != NULL )
2205 {
2206 libcerror_error_free(
2207 &error );
2208 }
2209 if( record_values != NULL )
2210 {
2211 libevtx_record_values_free(
2212 &record_values,
2213 NULL );
2214 }
2215 return( 0 );
2216 }
2217
2218 /* Tests the libevtx_record_values_get_utf16_computer_name_size function
2219 * Returns 1 if successful or 0 if not
2220 */
evtx_test_record_values_get_utf16_computer_name_size(void)2221 int evtx_test_record_values_get_utf16_computer_name_size(
2222 void )
2223 {
2224 libcerror_error_t *error = NULL;
2225 libevtx_record_values_t *record_values = NULL;
2226 size_t utf16_computer_name_size = 0;
2227 int result = 0;
2228 int utf16_computer_name_size_is_set = 0;
2229
2230 /* Initialize test
2231 */
2232 result = libevtx_record_values_initialize(
2233 &record_values,
2234 &error );
2235
2236 EVTX_TEST_ASSERT_EQUAL_INT(
2237 "result",
2238 result,
2239 1 );
2240
2241 EVTX_TEST_ASSERT_IS_NOT_NULL(
2242 "record_values",
2243 record_values );
2244
2245 EVTX_TEST_ASSERT_IS_NULL(
2246 "error",
2247 error );
2248
2249 /* Test regular cases
2250 */
2251 result = libevtx_record_values_get_utf16_computer_name_size(
2252 record_values,
2253 &utf16_computer_name_size,
2254 &error );
2255
2256 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
2257 "result",
2258 result,
2259 -1 );
2260
2261 EVTX_TEST_ASSERT_IS_NULL(
2262 "error",
2263 error );
2264
2265 utf16_computer_name_size_is_set = result;
2266
2267 /* Test error cases
2268 */
2269 result = libevtx_record_values_get_utf16_computer_name_size(
2270 NULL,
2271 &utf16_computer_name_size,
2272 &error );
2273
2274 EVTX_TEST_ASSERT_EQUAL_INT(
2275 "result",
2276 result,
2277 -1 );
2278
2279 EVTX_TEST_ASSERT_IS_NOT_NULL(
2280 "error",
2281 error );
2282
2283 libcerror_error_free(
2284 &error );
2285
2286 if( utf16_computer_name_size_is_set != 0 )
2287 {
2288 result = libevtx_record_values_get_utf16_computer_name_size(
2289 record_values,
2290 NULL,
2291 &error );
2292
2293 EVTX_TEST_ASSERT_EQUAL_INT(
2294 "result",
2295 result,
2296 -1 );
2297
2298 EVTX_TEST_ASSERT_IS_NOT_NULL(
2299 "error",
2300 error );
2301
2302 libcerror_error_free(
2303 &error );
2304 }
2305 /* Clean up
2306 */
2307 result = libevtx_record_values_free(
2308 &record_values,
2309 &error );
2310
2311 EVTX_TEST_ASSERT_EQUAL_INT(
2312 "result",
2313 result,
2314 1 );
2315
2316 EVTX_TEST_ASSERT_IS_NULL(
2317 "record_values",
2318 record_values );
2319
2320 EVTX_TEST_ASSERT_IS_NULL(
2321 "error",
2322 error );
2323
2324 return( 1 );
2325
2326 on_error:
2327 if( error != NULL )
2328 {
2329 libcerror_error_free(
2330 &error );
2331 }
2332 if( record_values != NULL )
2333 {
2334 libevtx_record_values_free(
2335 &record_values,
2336 NULL );
2337 }
2338 return( 0 );
2339 }
2340
2341 /* Tests the libevtx_record_values_get_utf16_computer_name function
2342 * Returns 1 if successful or 0 if not
2343 */
evtx_test_record_values_get_utf16_computer_name(void)2344 int evtx_test_record_values_get_utf16_computer_name(
2345 void )
2346 {
2347 uint16_t utf16_computer_name[ 512 ];
2348
2349 libcerror_error_t *error = NULL;
2350 libevtx_record_values_t *record_values = NULL;
2351 int result = 0;
2352 int utf16_computer_name_is_set = 0;
2353
2354 /* Initialize test
2355 */
2356 result = libevtx_record_values_initialize(
2357 &record_values,
2358 &error );
2359
2360 EVTX_TEST_ASSERT_EQUAL_INT(
2361 "result",
2362 result,
2363 1 );
2364
2365 EVTX_TEST_ASSERT_IS_NOT_NULL(
2366 "record_values",
2367 record_values );
2368
2369 EVTX_TEST_ASSERT_IS_NULL(
2370 "error",
2371 error );
2372
2373 /* Test regular cases
2374 */
2375 result = libevtx_record_values_get_utf16_computer_name(
2376 record_values,
2377 utf16_computer_name,
2378 512,
2379 &error );
2380
2381 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
2382 "result",
2383 result,
2384 -1 );
2385
2386 EVTX_TEST_ASSERT_IS_NULL(
2387 "error",
2388 error );
2389
2390 utf16_computer_name_is_set = result;
2391
2392 /* Test error cases
2393 */
2394 result = libevtx_record_values_get_utf16_computer_name(
2395 NULL,
2396 utf16_computer_name,
2397 512,
2398 &error );
2399
2400 EVTX_TEST_ASSERT_EQUAL_INT(
2401 "result",
2402 result,
2403 -1 );
2404
2405 EVTX_TEST_ASSERT_IS_NOT_NULL(
2406 "error",
2407 error );
2408
2409 libcerror_error_free(
2410 &error );
2411
2412 if( utf16_computer_name_is_set != 0 )
2413 {
2414 result = libevtx_record_values_get_utf16_computer_name(
2415 record_values,
2416 NULL,
2417 512,
2418 &error );
2419
2420 EVTX_TEST_ASSERT_EQUAL_INT(
2421 "result",
2422 result,
2423 -1 );
2424
2425 EVTX_TEST_ASSERT_IS_NOT_NULL(
2426 "error",
2427 error );
2428
2429 libcerror_error_free(
2430 &error );
2431
2432 result = libevtx_record_values_get_utf16_computer_name(
2433 record_values,
2434 utf16_computer_name,
2435 0,
2436 &error );
2437
2438 EVTX_TEST_ASSERT_EQUAL_INT(
2439 "result",
2440 result,
2441 -1 );
2442
2443 EVTX_TEST_ASSERT_IS_NOT_NULL(
2444 "error",
2445 error );
2446
2447 libcerror_error_free(
2448 &error );
2449
2450 result = libevtx_record_values_get_utf16_computer_name(
2451 record_values,
2452 utf16_computer_name,
2453 (size_t) SSIZE_MAX + 1,
2454 &error );
2455
2456 EVTX_TEST_ASSERT_EQUAL_INT(
2457 "result",
2458 result,
2459 -1 );
2460
2461 EVTX_TEST_ASSERT_IS_NOT_NULL(
2462 "error",
2463 error );
2464
2465 libcerror_error_free(
2466 &error );
2467 }
2468 /* Clean up
2469 */
2470 result = libevtx_record_values_free(
2471 &record_values,
2472 &error );
2473
2474 EVTX_TEST_ASSERT_EQUAL_INT(
2475 "result",
2476 result,
2477 1 );
2478
2479 EVTX_TEST_ASSERT_IS_NULL(
2480 "record_values",
2481 record_values );
2482
2483 EVTX_TEST_ASSERT_IS_NULL(
2484 "error",
2485 error );
2486
2487 return( 1 );
2488
2489 on_error:
2490 if( error != NULL )
2491 {
2492 libcerror_error_free(
2493 &error );
2494 }
2495 if( record_values != NULL )
2496 {
2497 libevtx_record_values_free(
2498 &record_values,
2499 NULL );
2500 }
2501 return( 0 );
2502 }
2503
2504 /* Tests the libevtx_record_values_get_utf8_user_security_identifier_size function
2505 * Returns 1 if successful or 0 if not
2506 */
evtx_test_record_values_get_utf8_user_security_identifier_size(void)2507 int evtx_test_record_values_get_utf8_user_security_identifier_size(
2508 void )
2509 {
2510 libcerror_error_t *error = NULL;
2511 libevtx_record_values_t *record_values = NULL;
2512 size_t utf8_user_security_identifier_size = 0;
2513 int result = 0;
2514 int utf8_user_security_identifier_size_is_set = 0;
2515
2516 /* Initialize test
2517 */
2518 result = libevtx_record_values_initialize(
2519 &record_values,
2520 &error );
2521
2522 EVTX_TEST_ASSERT_EQUAL_INT(
2523 "result",
2524 result,
2525 1 );
2526
2527 EVTX_TEST_ASSERT_IS_NOT_NULL(
2528 "record_values",
2529 record_values );
2530
2531 EVTX_TEST_ASSERT_IS_NULL(
2532 "error",
2533 error );
2534
2535 /* Test regular cases
2536 */
2537 result = libevtx_record_values_get_utf8_user_security_identifier_size(
2538 record_values,
2539 &utf8_user_security_identifier_size,
2540 &error );
2541
2542 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
2543 "result",
2544 result,
2545 -1 );
2546
2547 EVTX_TEST_ASSERT_IS_NULL(
2548 "error",
2549 error );
2550
2551 utf8_user_security_identifier_size_is_set = result;
2552
2553 /* Test error cases
2554 */
2555 result = libevtx_record_values_get_utf8_user_security_identifier_size(
2556 NULL,
2557 &utf8_user_security_identifier_size,
2558 &error );
2559
2560 EVTX_TEST_ASSERT_EQUAL_INT(
2561 "result",
2562 result,
2563 -1 );
2564
2565 EVTX_TEST_ASSERT_IS_NOT_NULL(
2566 "error",
2567 error );
2568
2569 libcerror_error_free(
2570 &error );
2571
2572 if( utf8_user_security_identifier_size_is_set != 0 )
2573 {
2574 result = libevtx_record_values_get_utf8_user_security_identifier_size(
2575 record_values,
2576 NULL,
2577 &error );
2578
2579 EVTX_TEST_ASSERT_EQUAL_INT(
2580 "result",
2581 result,
2582 -1 );
2583
2584 EVTX_TEST_ASSERT_IS_NOT_NULL(
2585 "error",
2586 error );
2587
2588 libcerror_error_free(
2589 &error );
2590 }
2591 /* Clean up
2592 */
2593 result = libevtx_record_values_free(
2594 &record_values,
2595 &error );
2596
2597 EVTX_TEST_ASSERT_EQUAL_INT(
2598 "result",
2599 result,
2600 1 );
2601
2602 EVTX_TEST_ASSERT_IS_NULL(
2603 "record_values",
2604 record_values );
2605
2606 EVTX_TEST_ASSERT_IS_NULL(
2607 "error",
2608 error );
2609
2610 return( 1 );
2611
2612 on_error:
2613 if( error != NULL )
2614 {
2615 libcerror_error_free(
2616 &error );
2617 }
2618 if( record_values != NULL )
2619 {
2620 libevtx_record_values_free(
2621 &record_values,
2622 NULL );
2623 }
2624 return( 0 );
2625 }
2626
2627 /* Tests the libevtx_record_values_get_utf8_user_security_identifier function
2628 * Returns 1 if successful or 0 if not
2629 */
evtx_test_record_values_get_utf8_user_security_identifier(void)2630 int evtx_test_record_values_get_utf8_user_security_identifier(
2631 void )
2632 {
2633 uint8_t utf8_user_security_identifier[ 512 ];
2634
2635 libcerror_error_t *error = NULL;
2636 libevtx_record_values_t *record_values = NULL;
2637 int result = 0;
2638 int utf8_user_security_identifier_is_set = 0;
2639
2640 /* Initialize test
2641 */
2642 result = libevtx_record_values_initialize(
2643 &record_values,
2644 &error );
2645
2646 EVTX_TEST_ASSERT_EQUAL_INT(
2647 "result",
2648 result,
2649 1 );
2650
2651 EVTX_TEST_ASSERT_IS_NOT_NULL(
2652 "record_values",
2653 record_values );
2654
2655 EVTX_TEST_ASSERT_IS_NULL(
2656 "error",
2657 error );
2658
2659 /* Test regular cases
2660 */
2661 result = libevtx_record_values_get_utf8_user_security_identifier(
2662 record_values,
2663 utf8_user_security_identifier,
2664 512,
2665 &error );
2666
2667 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
2668 "result",
2669 result,
2670 -1 );
2671
2672 EVTX_TEST_ASSERT_IS_NULL(
2673 "error",
2674 error );
2675
2676 utf8_user_security_identifier_is_set = result;
2677
2678 /* Test error cases
2679 */
2680 result = libevtx_record_values_get_utf8_user_security_identifier(
2681 NULL,
2682 utf8_user_security_identifier,
2683 512,
2684 &error );
2685
2686 EVTX_TEST_ASSERT_EQUAL_INT(
2687 "result",
2688 result,
2689 -1 );
2690
2691 EVTX_TEST_ASSERT_IS_NOT_NULL(
2692 "error",
2693 error );
2694
2695 libcerror_error_free(
2696 &error );
2697
2698 if( utf8_user_security_identifier_is_set != 0 )
2699 {
2700 result = libevtx_record_values_get_utf8_user_security_identifier(
2701 record_values,
2702 NULL,
2703 512,
2704 &error );
2705
2706 EVTX_TEST_ASSERT_EQUAL_INT(
2707 "result",
2708 result,
2709 -1 );
2710
2711 EVTX_TEST_ASSERT_IS_NOT_NULL(
2712 "error",
2713 error );
2714
2715 libcerror_error_free(
2716 &error );
2717
2718 result = libevtx_record_values_get_utf8_user_security_identifier(
2719 record_values,
2720 utf8_user_security_identifier,
2721 0,
2722 &error );
2723
2724 EVTX_TEST_ASSERT_EQUAL_INT(
2725 "result",
2726 result,
2727 -1 );
2728
2729 EVTX_TEST_ASSERT_IS_NOT_NULL(
2730 "error",
2731 error );
2732
2733 libcerror_error_free(
2734 &error );
2735
2736 result = libevtx_record_values_get_utf8_user_security_identifier(
2737 record_values,
2738 utf8_user_security_identifier,
2739 (size_t) SSIZE_MAX + 1,
2740 &error );
2741
2742 EVTX_TEST_ASSERT_EQUAL_INT(
2743 "result",
2744 result,
2745 -1 );
2746
2747 EVTX_TEST_ASSERT_IS_NOT_NULL(
2748 "error",
2749 error );
2750
2751 libcerror_error_free(
2752 &error );
2753 }
2754 /* Clean up
2755 */
2756 result = libevtx_record_values_free(
2757 &record_values,
2758 &error );
2759
2760 EVTX_TEST_ASSERT_EQUAL_INT(
2761 "result",
2762 result,
2763 1 );
2764
2765 EVTX_TEST_ASSERT_IS_NULL(
2766 "record_values",
2767 record_values );
2768
2769 EVTX_TEST_ASSERT_IS_NULL(
2770 "error",
2771 error );
2772
2773 return( 1 );
2774
2775 on_error:
2776 if( error != NULL )
2777 {
2778 libcerror_error_free(
2779 &error );
2780 }
2781 if( record_values != NULL )
2782 {
2783 libevtx_record_values_free(
2784 &record_values,
2785 NULL );
2786 }
2787 return( 0 );
2788 }
2789
2790 /* Tests the libevtx_record_values_get_utf16_user_security_identifier_size function
2791 * Returns 1 if successful or 0 if not
2792 */
evtx_test_record_values_get_utf16_user_security_identifier_size(void)2793 int evtx_test_record_values_get_utf16_user_security_identifier_size(
2794 void )
2795 {
2796 libcerror_error_t *error = NULL;
2797 libevtx_record_values_t *record_values = NULL;
2798 size_t utf16_user_security_identifier_size = 0;
2799 int result = 0;
2800 int utf16_user_security_identifier_size_is_set = 0;
2801
2802 /* Initialize test
2803 */
2804 result = libevtx_record_values_initialize(
2805 &record_values,
2806 &error );
2807
2808 EVTX_TEST_ASSERT_EQUAL_INT(
2809 "result",
2810 result,
2811 1 );
2812
2813 EVTX_TEST_ASSERT_IS_NOT_NULL(
2814 "record_values",
2815 record_values );
2816
2817 EVTX_TEST_ASSERT_IS_NULL(
2818 "error",
2819 error );
2820
2821 /* Test regular cases
2822 */
2823 result = libevtx_record_values_get_utf16_user_security_identifier_size(
2824 record_values,
2825 &utf16_user_security_identifier_size,
2826 &error );
2827
2828 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
2829 "result",
2830 result,
2831 -1 );
2832
2833 EVTX_TEST_ASSERT_IS_NULL(
2834 "error",
2835 error );
2836
2837 utf16_user_security_identifier_size_is_set = result;
2838
2839 /* Test error cases
2840 */
2841 result = libevtx_record_values_get_utf16_user_security_identifier_size(
2842 NULL,
2843 &utf16_user_security_identifier_size,
2844 &error );
2845
2846 EVTX_TEST_ASSERT_EQUAL_INT(
2847 "result",
2848 result,
2849 -1 );
2850
2851 EVTX_TEST_ASSERT_IS_NOT_NULL(
2852 "error",
2853 error );
2854
2855 libcerror_error_free(
2856 &error );
2857
2858 if( utf16_user_security_identifier_size_is_set != 0 )
2859 {
2860 result = libevtx_record_values_get_utf16_user_security_identifier_size(
2861 record_values,
2862 NULL,
2863 &error );
2864
2865 EVTX_TEST_ASSERT_EQUAL_INT(
2866 "result",
2867 result,
2868 -1 );
2869
2870 EVTX_TEST_ASSERT_IS_NOT_NULL(
2871 "error",
2872 error );
2873
2874 libcerror_error_free(
2875 &error );
2876 }
2877 /* Clean up
2878 */
2879 result = libevtx_record_values_free(
2880 &record_values,
2881 &error );
2882
2883 EVTX_TEST_ASSERT_EQUAL_INT(
2884 "result",
2885 result,
2886 1 );
2887
2888 EVTX_TEST_ASSERT_IS_NULL(
2889 "record_values",
2890 record_values );
2891
2892 EVTX_TEST_ASSERT_IS_NULL(
2893 "error",
2894 error );
2895
2896 return( 1 );
2897
2898 on_error:
2899 if( error != NULL )
2900 {
2901 libcerror_error_free(
2902 &error );
2903 }
2904 if( record_values != NULL )
2905 {
2906 libevtx_record_values_free(
2907 &record_values,
2908 NULL );
2909 }
2910 return( 0 );
2911 }
2912
2913 /* Tests the libevtx_record_values_get_utf16_user_security_identifier function
2914 * Returns 1 if successful or 0 if not
2915 */
evtx_test_record_values_get_utf16_user_security_identifier(void)2916 int evtx_test_record_values_get_utf16_user_security_identifier(
2917 void )
2918 {
2919 uint16_t utf16_user_security_identifier[ 512 ];
2920
2921 libcerror_error_t *error = NULL;
2922 libevtx_record_values_t *record_values = NULL;
2923 int result = 0;
2924 int utf16_user_security_identifier_is_set = 0;
2925
2926 /* Initialize test
2927 */
2928 result = libevtx_record_values_initialize(
2929 &record_values,
2930 &error );
2931
2932 EVTX_TEST_ASSERT_EQUAL_INT(
2933 "result",
2934 result,
2935 1 );
2936
2937 EVTX_TEST_ASSERT_IS_NOT_NULL(
2938 "record_values",
2939 record_values );
2940
2941 EVTX_TEST_ASSERT_IS_NULL(
2942 "error",
2943 error );
2944
2945 /* Test regular cases
2946 */
2947 result = libevtx_record_values_get_utf16_user_security_identifier(
2948 record_values,
2949 utf16_user_security_identifier,
2950 512,
2951 &error );
2952
2953 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
2954 "result",
2955 result,
2956 -1 );
2957
2958 EVTX_TEST_ASSERT_IS_NULL(
2959 "error",
2960 error );
2961
2962 utf16_user_security_identifier_is_set = result;
2963
2964 /* Test error cases
2965 */
2966 result = libevtx_record_values_get_utf16_user_security_identifier(
2967 NULL,
2968 utf16_user_security_identifier,
2969 512,
2970 &error );
2971
2972 EVTX_TEST_ASSERT_EQUAL_INT(
2973 "result",
2974 result,
2975 -1 );
2976
2977 EVTX_TEST_ASSERT_IS_NOT_NULL(
2978 "error",
2979 error );
2980
2981 libcerror_error_free(
2982 &error );
2983
2984 if( utf16_user_security_identifier_is_set != 0 )
2985 {
2986 result = libevtx_record_values_get_utf16_user_security_identifier(
2987 record_values,
2988 NULL,
2989 512,
2990 &error );
2991
2992 EVTX_TEST_ASSERT_EQUAL_INT(
2993 "result",
2994 result,
2995 -1 );
2996
2997 EVTX_TEST_ASSERT_IS_NOT_NULL(
2998 "error",
2999 error );
3000
3001 libcerror_error_free(
3002 &error );
3003
3004 result = libevtx_record_values_get_utf16_user_security_identifier(
3005 record_values,
3006 utf16_user_security_identifier,
3007 0,
3008 &error );
3009
3010 EVTX_TEST_ASSERT_EQUAL_INT(
3011 "result",
3012 result,
3013 -1 );
3014
3015 EVTX_TEST_ASSERT_IS_NOT_NULL(
3016 "error",
3017 error );
3018
3019 libcerror_error_free(
3020 &error );
3021
3022 result = libevtx_record_values_get_utf16_user_security_identifier(
3023 record_values,
3024 utf16_user_security_identifier,
3025 (size_t) SSIZE_MAX + 1,
3026 &error );
3027
3028 EVTX_TEST_ASSERT_EQUAL_INT(
3029 "result",
3030 result,
3031 -1 );
3032
3033 EVTX_TEST_ASSERT_IS_NOT_NULL(
3034 "error",
3035 error );
3036
3037 libcerror_error_free(
3038 &error );
3039 }
3040 /* Clean up
3041 */
3042 result = libevtx_record_values_free(
3043 &record_values,
3044 &error );
3045
3046 EVTX_TEST_ASSERT_EQUAL_INT(
3047 "result",
3048 result,
3049 1 );
3050
3051 EVTX_TEST_ASSERT_IS_NULL(
3052 "record_values",
3053 record_values );
3054
3055 EVTX_TEST_ASSERT_IS_NULL(
3056 "error",
3057 error );
3058
3059 return( 1 );
3060
3061 on_error:
3062 if( error != NULL )
3063 {
3064 libcerror_error_free(
3065 &error );
3066 }
3067 if( record_values != NULL )
3068 {
3069 libevtx_record_values_free(
3070 &record_values,
3071 NULL );
3072 }
3073 return( 0 );
3074 }
3075
3076 /* Tests the libevtx_record_values_get_utf8_xml_string_size function
3077 * Returns 1 if successful or 0 if not
3078 */
evtx_test_record_values_get_utf8_xml_string_size(void)3079 int evtx_test_record_values_get_utf8_xml_string_size(
3080 void )
3081 {
3082 libcerror_error_t *error = NULL;
3083 libevtx_record_values_t *record_values = NULL;
3084 size_t utf8_xml_string_size = 0;
3085 int result = 0;
3086 int utf8_xml_string_size_is_set = 0;
3087
3088 /* Initialize test
3089 */
3090 result = libevtx_record_values_initialize(
3091 &record_values,
3092 &error );
3093
3094 EVTX_TEST_ASSERT_EQUAL_INT(
3095 "result",
3096 result,
3097 1 );
3098
3099 EVTX_TEST_ASSERT_IS_NOT_NULL(
3100 "record_values",
3101 record_values );
3102
3103 EVTX_TEST_ASSERT_IS_NULL(
3104 "error",
3105 error );
3106
3107 /* Test regular cases
3108 */
3109 result = libevtx_record_values_get_utf8_xml_string_size(
3110 record_values,
3111 &utf8_xml_string_size,
3112 &error );
3113
3114 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
3115 "result",
3116 result,
3117 -1 );
3118
3119 EVTX_TEST_ASSERT_IS_NULL(
3120 "error",
3121 error );
3122
3123 utf8_xml_string_size_is_set = result;
3124
3125 /* Test error cases
3126 */
3127 result = libevtx_record_values_get_utf8_xml_string_size(
3128 NULL,
3129 &utf8_xml_string_size,
3130 &error );
3131
3132 EVTX_TEST_ASSERT_EQUAL_INT(
3133 "result",
3134 result,
3135 -1 );
3136
3137 EVTX_TEST_ASSERT_IS_NOT_NULL(
3138 "error",
3139 error );
3140
3141 libcerror_error_free(
3142 &error );
3143
3144 if( utf8_xml_string_size_is_set != 0 )
3145 {
3146 result = libevtx_record_values_get_utf8_xml_string_size(
3147 record_values,
3148 NULL,
3149 &error );
3150
3151 EVTX_TEST_ASSERT_EQUAL_INT(
3152 "result",
3153 result,
3154 -1 );
3155
3156 EVTX_TEST_ASSERT_IS_NOT_NULL(
3157 "error",
3158 error );
3159
3160 libcerror_error_free(
3161 &error );
3162 }
3163 /* Clean up
3164 */
3165 result = libevtx_record_values_free(
3166 &record_values,
3167 &error );
3168
3169 EVTX_TEST_ASSERT_EQUAL_INT(
3170 "result",
3171 result,
3172 1 );
3173
3174 EVTX_TEST_ASSERT_IS_NULL(
3175 "record_values",
3176 record_values );
3177
3178 EVTX_TEST_ASSERT_IS_NULL(
3179 "error",
3180 error );
3181
3182 return( 1 );
3183
3184 on_error:
3185 if( error != NULL )
3186 {
3187 libcerror_error_free(
3188 &error );
3189 }
3190 if( record_values != NULL )
3191 {
3192 libevtx_record_values_free(
3193 &record_values,
3194 NULL );
3195 }
3196 return( 0 );
3197 }
3198
3199 /* Tests the libevtx_record_values_get_utf8_xml_string function
3200 * Returns 1 if successful or 0 if not
3201 */
evtx_test_record_values_get_utf8_xml_string(void)3202 int evtx_test_record_values_get_utf8_xml_string(
3203 void )
3204 {
3205 uint8_t utf8_xml_string[ 512 ];
3206
3207 libcerror_error_t *error = NULL;
3208 libevtx_record_values_t *record_values = NULL;
3209 int result = 0;
3210 int utf8_xml_string_is_set = 0;
3211
3212 /* Initialize test
3213 */
3214 result = libevtx_record_values_initialize(
3215 &record_values,
3216 &error );
3217
3218 EVTX_TEST_ASSERT_EQUAL_INT(
3219 "result",
3220 result,
3221 1 );
3222
3223 EVTX_TEST_ASSERT_IS_NOT_NULL(
3224 "record_values",
3225 record_values );
3226
3227 EVTX_TEST_ASSERT_IS_NULL(
3228 "error",
3229 error );
3230
3231 /* Test regular cases
3232 */
3233 result = libevtx_record_values_get_utf8_xml_string(
3234 record_values,
3235 utf8_xml_string,
3236 512,
3237 &error );
3238
3239 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
3240 "result",
3241 result,
3242 -1 );
3243
3244 EVTX_TEST_ASSERT_IS_NULL(
3245 "error",
3246 error );
3247
3248 utf8_xml_string_is_set = result;
3249
3250 /* Test error cases
3251 */
3252 result = libevtx_record_values_get_utf8_xml_string(
3253 NULL,
3254 utf8_xml_string,
3255 512,
3256 &error );
3257
3258 EVTX_TEST_ASSERT_EQUAL_INT(
3259 "result",
3260 result,
3261 -1 );
3262
3263 EVTX_TEST_ASSERT_IS_NOT_NULL(
3264 "error",
3265 error );
3266
3267 libcerror_error_free(
3268 &error );
3269
3270 if( utf8_xml_string_is_set != 0 )
3271 {
3272 result = libevtx_record_values_get_utf8_xml_string(
3273 record_values,
3274 NULL,
3275 512,
3276 &error );
3277
3278 EVTX_TEST_ASSERT_EQUAL_INT(
3279 "result",
3280 result,
3281 -1 );
3282
3283 EVTX_TEST_ASSERT_IS_NOT_NULL(
3284 "error",
3285 error );
3286
3287 libcerror_error_free(
3288 &error );
3289
3290 result = libevtx_record_values_get_utf8_xml_string(
3291 record_values,
3292 utf8_xml_string,
3293 0,
3294 &error );
3295
3296 EVTX_TEST_ASSERT_EQUAL_INT(
3297 "result",
3298 result,
3299 -1 );
3300
3301 EVTX_TEST_ASSERT_IS_NOT_NULL(
3302 "error",
3303 error );
3304
3305 libcerror_error_free(
3306 &error );
3307
3308 result = libevtx_record_values_get_utf8_xml_string(
3309 record_values,
3310 utf8_xml_string,
3311 (size_t) SSIZE_MAX + 1,
3312 &error );
3313
3314 EVTX_TEST_ASSERT_EQUAL_INT(
3315 "result",
3316 result,
3317 -1 );
3318
3319 EVTX_TEST_ASSERT_IS_NOT_NULL(
3320 "error",
3321 error );
3322
3323 libcerror_error_free(
3324 &error );
3325 }
3326 /* Clean up
3327 */
3328 result = libevtx_record_values_free(
3329 &record_values,
3330 &error );
3331
3332 EVTX_TEST_ASSERT_EQUAL_INT(
3333 "result",
3334 result,
3335 1 );
3336
3337 EVTX_TEST_ASSERT_IS_NULL(
3338 "record_values",
3339 record_values );
3340
3341 EVTX_TEST_ASSERT_IS_NULL(
3342 "error",
3343 error );
3344
3345 return( 1 );
3346
3347 on_error:
3348 if( error != NULL )
3349 {
3350 libcerror_error_free(
3351 &error );
3352 }
3353 if( record_values != NULL )
3354 {
3355 libevtx_record_values_free(
3356 &record_values,
3357 NULL );
3358 }
3359 return( 0 );
3360 }
3361
3362 /* Tests the libevtx_record_values_get_utf16_xml_string_size function
3363 * Returns 1 if successful or 0 if not
3364 */
evtx_test_record_values_get_utf16_xml_string_size(void)3365 int evtx_test_record_values_get_utf16_xml_string_size(
3366 void )
3367 {
3368 libcerror_error_t *error = NULL;
3369 libevtx_record_values_t *record_values = NULL;
3370 size_t utf16_xml_string_size = 0;
3371 int result = 0;
3372 int utf16_xml_string_size_is_set = 0;
3373
3374 /* Initialize test
3375 */
3376 result = libevtx_record_values_initialize(
3377 &record_values,
3378 &error );
3379
3380 EVTX_TEST_ASSERT_EQUAL_INT(
3381 "result",
3382 result,
3383 1 );
3384
3385 EVTX_TEST_ASSERT_IS_NOT_NULL(
3386 "record_values",
3387 record_values );
3388
3389 EVTX_TEST_ASSERT_IS_NULL(
3390 "error",
3391 error );
3392
3393 /* Test regular cases
3394 */
3395 result = libevtx_record_values_get_utf16_xml_string_size(
3396 record_values,
3397 &utf16_xml_string_size,
3398 &error );
3399
3400 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
3401 "result",
3402 result,
3403 -1 );
3404
3405 EVTX_TEST_ASSERT_IS_NULL(
3406 "error",
3407 error );
3408
3409 utf16_xml_string_size_is_set = result;
3410
3411 /* Test error cases
3412 */
3413 result = libevtx_record_values_get_utf16_xml_string_size(
3414 NULL,
3415 &utf16_xml_string_size,
3416 &error );
3417
3418 EVTX_TEST_ASSERT_EQUAL_INT(
3419 "result",
3420 result,
3421 -1 );
3422
3423 EVTX_TEST_ASSERT_IS_NOT_NULL(
3424 "error",
3425 error );
3426
3427 libcerror_error_free(
3428 &error );
3429
3430 if( utf16_xml_string_size_is_set != 0 )
3431 {
3432 result = libevtx_record_values_get_utf16_xml_string_size(
3433 record_values,
3434 NULL,
3435 &error );
3436
3437 EVTX_TEST_ASSERT_EQUAL_INT(
3438 "result",
3439 result,
3440 -1 );
3441
3442 EVTX_TEST_ASSERT_IS_NOT_NULL(
3443 "error",
3444 error );
3445
3446 libcerror_error_free(
3447 &error );
3448 }
3449 /* Clean up
3450 */
3451 result = libevtx_record_values_free(
3452 &record_values,
3453 &error );
3454
3455 EVTX_TEST_ASSERT_EQUAL_INT(
3456 "result",
3457 result,
3458 1 );
3459
3460 EVTX_TEST_ASSERT_IS_NULL(
3461 "record_values",
3462 record_values );
3463
3464 EVTX_TEST_ASSERT_IS_NULL(
3465 "error",
3466 error );
3467
3468 return( 1 );
3469
3470 on_error:
3471 if( error != NULL )
3472 {
3473 libcerror_error_free(
3474 &error );
3475 }
3476 if( record_values != NULL )
3477 {
3478 libevtx_record_values_free(
3479 &record_values,
3480 NULL );
3481 }
3482 return( 0 );
3483 }
3484
3485 /* Tests the libevtx_record_values_get_utf16_xml_string function
3486 * Returns 1 if successful or 0 if not
3487 */
evtx_test_record_values_get_utf16_xml_string(void)3488 int evtx_test_record_values_get_utf16_xml_string(
3489 void )
3490 {
3491 uint16_t utf16_xml_string[ 512 ];
3492
3493 libcerror_error_t *error = NULL;
3494 libevtx_record_values_t *record_values = NULL;
3495 int result = 0;
3496 int utf16_xml_string_is_set = 0;
3497
3498 /* Initialize test
3499 */
3500 result = libevtx_record_values_initialize(
3501 &record_values,
3502 &error );
3503
3504 EVTX_TEST_ASSERT_EQUAL_INT(
3505 "result",
3506 result,
3507 1 );
3508
3509 EVTX_TEST_ASSERT_IS_NOT_NULL(
3510 "record_values",
3511 record_values );
3512
3513 EVTX_TEST_ASSERT_IS_NULL(
3514 "error",
3515 error );
3516
3517 /* Test regular cases
3518 */
3519 result = libevtx_record_values_get_utf16_xml_string(
3520 record_values,
3521 utf16_xml_string,
3522 512,
3523 &error );
3524
3525 EVTX_TEST_ASSERT_NOT_EQUAL_INT(
3526 "result",
3527 result,
3528 -1 );
3529
3530 EVTX_TEST_ASSERT_IS_NULL(
3531 "error",
3532 error );
3533
3534 utf16_xml_string_is_set = result;
3535
3536 /* Test error cases
3537 */
3538 result = libevtx_record_values_get_utf16_xml_string(
3539 NULL,
3540 utf16_xml_string,
3541 512,
3542 &error );
3543
3544 EVTX_TEST_ASSERT_EQUAL_INT(
3545 "result",
3546 result,
3547 -1 );
3548
3549 EVTX_TEST_ASSERT_IS_NOT_NULL(
3550 "error",
3551 error );
3552
3553 libcerror_error_free(
3554 &error );
3555
3556 if( utf16_xml_string_is_set != 0 )
3557 {
3558 result = libevtx_record_values_get_utf16_xml_string(
3559 record_values,
3560 NULL,
3561 512,
3562 &error );
3563
3564 EVTX_TEST_ASSERT_EQUAL_INT(
3565 "result",
3566 result,
3567 -1 );
3568
3569 EVTX_TEST_ASSERT_IS_NOT_NULL(
3570 "error",
3571 error );
3572
3573 libcerror_error_free(
3574 &error );
3575
3576 result = libevtx_record_values_get_utf16_xml_string(
3577 record_values,
3578 utf16_xml_string,
3579 0,
3580 &error );
3581
3582 EVTX_TEST_ASSERT_EQUAL_INT(
3583 "result",
3584 result,
3585 -1 );
3586
3587 EVTX_TEST_ASSERT_IS_NOT_NULL(
3588 "error",
3589 error );
3590
3591 libcerror_error_free(
3592 &error );
3593
3594 result = libevtx_record_values_get_utf16_xml_string(
3595 record_values,
3596 utf16_xml_string,
3597 (size_t) SSIZE_MAX + 1,
3598 &error );
3599
3600 EVTX_TEST_ASSERT_EQUAL_INT(
3601 "result",
3602 result,
3603 -1 );
3604
3605 EVTX_TEST_ASSERT_IS_NOT_NULL(
3606 "error",
3607 error );
3608
3609 libcerror_error_free(
3610 &error );
3611 }
3612 /* Clean up
3613 */
3614 result = libevtx_record_values_free(
3615 &record_values,
3616 &error );
3617
3618 EVTX_TEST_ASSERT_EQUAL_INT(
3619 "result",
3620 result,
3621 1 );
3622
3623 EVTX_TEST_ASSERT_IS_NULL(
3624 "record_values",
3625 record_values );
3626
3627 EVTX_TEST_ASSERT_IS_NULL(
3628 "error",
3629 error );
3630
3631 return( 1 );
3632
3633 on_error:
3634 if( error != NULL )
3635 {
3636 libcerror_error_free(
3637 &error );
3638 }
3639 if( record_values != NULL )
3640 {
3641 libevtx_record_values_free(
3642 &record_values,
3643 NULL );
3644 }
3645 return( 0 );
3646 }
3647
3648 #endif /* defined( __GNUC__ ) && !defined( LIBEVTX_DLL_IMPORT ) */
3649
3650 /* The main program
3651 */
3652 #if defined( HAVE_WIDE_SYSTEM_CHARACTER )
wmain(int argc EVTX_TEST_ATTRIBUTE_UNUSED,wchar_t * const argv[]EVTX_TEST_ATTRIBUTE_UNUSED)3653 int wmain(
3654 int argc EVTX_TEST_ATTRIBUTE_UNUSED,
3655 wchar_t * const argv[] EVTX_TEST_ATTRIBUTE_UNUSED )
3656 #else
3657 int main(
3658 int argc EVTX_TEST_ATTRIBUTE_UNUSED,
3659 char * const argv[] EVTX_TEST_ATTRIBUTE_UNUSED )
3660 #endif
3661 {
3662 EVTX_TEST_UNREFERENCED_PARAMETER( argc )
3663 EVTX_TEST_UNREFERENCED_PARAMETER( argv )
3664
3665 #if defined( __GNUC__ ) && !defined( LIBEVTX_DLL_IMPORT )
3666
3667 EVTX_TEST_RUN(
3668 "libevtx_record_values_initialize",
3669 evtx_test_record_values_initialize );
3670
3671 EVTX_TEST_RUN(
3672 "libevtx_record_values_free",
3673 evtx_test_record_values_free );
3674
3675 EVTX_TEST_RUN(
3676 "libevtx_record_values_clone",
3677 evtx_test_record_values_clone );
3678
3679 #if defined( TODO )
3680
3681 /* TODO: add tests for libevtx_record_values_read_header */
3682
3683 /* TODO: add tests for libevtx_record_values_read_xml_document */
3684
3685 EVTX_TEST_RUN(
3686 "libevtx_record_values_get_event_identifier",
3687 evtx_test_record_values_get_event_identifier );
3688
3689 EVTX_TEST_RUN(
3690 "libevtx_record_values_get_event_identifier_qualifiers",
3691 evtx_test_record_values_get_event_identifier_qualifiers );
3692
3693 EVTX_TEST_RUN(
3694 "libevtx_record_values_get_event_level",
3695 evtx_test_record_values_get_event_level );
3696
3697 EVTX_TEST_RUN(
3698 "libevtx_record_values_get_utf8_provider_identifier_size",
3699 evtx_test_record_values_get_utf8_provider_identifier_size );
3700
3701 EVTX_TEST_RUN(
3702 "libevtx_record_values_get_utf8_provider_identifier",
3703 evtx_test_record_values_get_utf8_provider_identifier );
3704
3705 EVTX_TEST_RUN(
3706 "libevtx_record_values_get_utf16_provider_identifier_size",
3707 evtx_test_record_values_get_utf16_provider_identifier_size );
3708
3709 EVTX_TEST_RUN(
3710 "libevtx_record_values_get_utf16_provider_identifier",
3711 evtx_test_record_values_get_utf16_provider_identifier );
3712
3713 EVTX_TEST_RUN(
3714 "libevtx_record_values_get_utf8_source_name_size",
3715 evtx_test_record_values_get_utf8_source_name_size );
3716
3717 EVTX_TEST_RUN(
3718 "libevtx_record_values_get_utf8_source_name",
3719 evtx_test_record_values_get_utf8_source_name );
3720
3721 EVTX_TEST_RUN(
3722 "libevtx_record_values_get_utf16_source_name_size",
3723 evtx_test_record_values_get_utf16_source_name_size );
3724
3725 EVTX_TEST_RUN(
3726 "libevtx_record_values_get_utf16_source_name",
3727 evtx_test_record_values_get_utf16_source_name );
3728
3729 EVTX_TEST_RUN(
3730 "libevtx_record_values_get_utf8_computer_name_size",
3731 evtx_test_record_values_get_utf8_computer_name_size );
3732
3733 EVTX_TEST_RUN(
3734 "libevtx_record_values_get_utf8_computer_name",
3735 evtx_test_record_values_get_utf8_computer_name );
3736
3737 EVTX_TEST_RUN(
3738 "libevtx_record_values_get_utf16_computer_name_size",
3739 evtx_test_record_values_get_utf16_computer_name_size );
3740
3741 EVTX_TEST_RUN(
3742 "libevtx_record_values_get_utf16_computer_name",
3743 evtx_test_record_values_get_utf16_computer_name );
3744
3745 EVTX_TEST_RUN(
3746 "libevtx_record_values_get_utf8_user_security_identifier_size",
3747 evtx_test_record_values_get_utf8_user_security_identifier_size );
3748
3749 EVTX_TEST_RUN(
3750 "libevtx_record_values_get_utf8_user_security_identifier",
3751 evtx_test_record_values_get_utf8_user_security_identifier );
3752
3753 EVTX_TEST_RUN(
3754 "libevtx_record_values_get_utf16_user_security_identifier_size",
3755 evtx_test_record_values_get_utf16_user_security_identifier_size );
3756
3757 EVTX_TEST_RUN(
3758 "libevtx_record_values_get_utf16_user_security_identifier",
3759 evtx_test_record_values_get_utf16_user_security_identifier );
3760
3761 /* TODO: add tests for libevtx_record_values_parse_data */
3762
3763 /* TODO: add tests for libevtx_record_values_get_number_of_strings */
3764
3765 /* TODO: add tests for libevtx_record_values_get_utf8_string_size */
3766
3767 /* TODO: add tests for libevtx_record_values_get_utf8_string */
3768
3769 /* TODO: add tests for libevtx_record_values_get_utf16_string_size */
3770
3771 /* TODO: add tests for libevtx_record_values_get_utf16_string */
3772
3773 /* TODO: add tests for libevtx_record_values_get_data_size */
3774
3775 /* TODO: add tests for libevtx_record_values_get_data */
3776
3777 EVTX_TEST_RUN(
3778 "libevtx_record_values_get_utf8_xml_string_size",
3779 evtx_test_record_values_get_utf8_xml_string_size );
3780
3781 EVTX_TEST_RUN(
3782 "libevtx_record_values_get_utf8_xml_string",
3783 evtx_test_record_values_get_utf8_xml_string );
3784
3785 EVTX_TEST_RUN(
3786 "libevtx_record_values_get_utf16_xml_string_size",
3787 evtx_test_record_values_get_utf16_xml_string_size );
3788
3789 EVTX_TEST_RUN(
3790 "libevtx_record_values_get_utf16_xml_string",
3791 evtx_test_record_values_get_utf16_xml_string );
3792
3793 #endif /* defined( TODO ) */
3794
3795 #endif /* defined( __GNUC__ ) && !defined( LIBEVTX_DLL_IMPORT ) */
3796
3797 return( EXIT_SUCCESS );
3798
3799 on_error:
3800 return( EXIT_FAILURE );
3801 }
3802
3803