++#endif
++
++#include ""evt_test_libcerror.h""
++#include ""evt_test_libevt.h""
++#include ""evt_test_macros.h""
++#include ""evt_test_memory.h""
++#include ""evt_test_unused.h""
++
++#include ""../libevt/libevt_event_record.h""
++
++uint8_t evt_test_event_record_data1[ 144 ] = {
++ 0x90, 0x00, 0x00, 0x00, 0x4c, 0x66, 0x4c, 0x65, 0x01, 0x00, 0x00, 0x00, 0x79, 0x42, 0xdb, 0x4c,
++ 0x79, 0x42, 0xdb, 0x4c, 0xe8, 0x03, 0x00, 0x40, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
++ 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
++ 0x04, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x6f, 0x00, 0x61, 0x00, 0x64, 0x00,
++ 0x50, 0x00, 0x65, 0x00, 0x72, 0x00, 0x66, 0x00, 0x00, 0x00, 0x57, 0x00, 0x4b, 0x00, 0x53, 0x00,
++ 0x2d, 0x00, 0x57, 0x00, 0x49, 0x00, 0x4e, 0x00, 0x58, 0x00, 0x50, 0x00, 0x33, 0x00, 0x32, 0x00,
++ 0x42, 0x00, 0x49, 0x00, 0x54, 0x00, 0x00, 0x00, 0x52, 0x00, 0x53, 0x00, 0x56, 0x00, 0x50, 0x00,
++ 0x00, 0x00, 0x51, 0x00, 0x6f, 0x00, 0x53, 0x00, 0x20, 0x00, 0x52, 0x00, 0x53, 0x00, 0x56, 0x00,
++ 0x50, 0x00, 0x00, 0x00, 0x0c, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00 };
++
++#if defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT )
++
++/* Tests the libevt_event_record_initialize function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_initialize(
++ void )
++{
++ libcerror_error_t *error = NULL;
++ libevt_event_record_t *event_record = NULL;
++ int result = 0;
++
++#if defined( HAVE_EVT_TEST_MEMORY )
++ int number_of_malloc_fail_tests = 1;
++ int number_of_memset_fail_tests = 1;
++ int test_number = 0;
++#endif
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_initialize(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = libevt_event_record_free(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_initialize(
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ event_record = (libevt_event_record_t *) 0x12345678UL;
++
++ result = libevt_event_record_initialize(
++ &event_record,
++ &error );
++
++ event_record = NULL;
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++#if defined( HAVE_EVT_TEST_MEMORY )
++
++ for( test_number = 0;
++ test_number < number_of_malloc_fail_tests;
++ test_number++ )
++ {
++ /* Test libevt_event_record_initialize with malloc failing
++ */
++ evt_test_malloc_attempts_before_fail = test_number;
++
++ result = libevt_event_record_initialize(
++ &event_record,
++ &error );
++
++ if( evt_test_malloc_attempts_before_fail != -1 )
++ {
++ evt_test_malloc_attempts_before_fail = -1;
++
++ if( event_record != NULL )
++ {
++ libevt_event_record_free(
++ &event_record,
++ NULL );
++ }
++ }
++ else
++ {
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++ }
++ }
++ for( test_number = 0;
++ test_number < number_of_memset_fail_tests;
++ test_number++ )
++ {
++ /* Test libevt_event_record_initialize with memset failing
++ */
++ evt_test_memset_attempts_before_fail = test_number;
++
++ result = libevt_event_record_initialize(
++ &event_record,
++ &error );
++
++ if( evt_test_memset_attempts_before_fail != -1 )
++ {
++ evt_test_memset_attempts_before_fail = -1;
++
++ if( event_record != NULL )
++ {
++ libevt_event_record_free(
++ &event_record,
++ NULL );
++ }
++ }
++ else
++ {
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++ }
++ }
++#endif /* defined( HAVE_EVT_TEST_MEMORY ) */
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ if( event_record != NULL )
++ {
++ libevt_event_record_free(
++ &event_record,
++ NULL );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_free function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_free(
++ void )
++{
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test error cases
++ */
++ result = libevt_event_record_free(
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_read_data function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_read_data(
++ void )
++{
++ libcerror_error_t *error = NULL;
++ libevt_event_record_t *event_record = NULL;
++ int result = 0;
++
++#if defined( HAVE_EVT_TEST_MEMORY )
++#if defined( OPTIMIZATION_DISABLED )
++ int number_of_memcpy_fail_tests = 2;
++#endif
++ int number_of_malloc_fail_tests = 2;
++ int test_number = 0;
++#endif
++
++ /* Initialize test
++ */
++ result = libevt_event_record_initialize(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ 144,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ 144,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ /* Clean up
++ */
++ result = libevt_event_record_free(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Initialize test
++ */
++ result = libevt_event_record_initialize(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_read_data(
++ NULL,
++ evt_test_event_record_data1,
++ 144,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_read_data(
++ event_record,
++ NULL,
++ 144,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++#if defined( HAVE_EVT_TEST_MEMORY )
++
++ for( test_number = 0;
++ test_number < number_of_malloc_fail_tests;
++ test_number++ )
++ {
++ /* Test libevt_event_record_initialize with malloc failing
++ */
++ evt_test_malloc_attempts_before_fail = test_number;
++
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ 144,
++ &error );
++
++ if( evt_test_malloc_attempts_before_fail != -1 )
++ {
++ evt_test_malloc_attempts_before_fail = -1;
++ }
++ else
++ {
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++ }
++ }
++#if defined( OPTIMIZATION_DISABLED )
++ for( test_number = 0;
++ test_number < number_of_memcpy_fail_tests;
++ test_number++ )
++ {
++ /* Test libevt_event_record_initialize with memcpy failing
++ */
++ evt_test_memcpy_attempts_before_fail = test_number;
++
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ 144,
++ &error );
++
++ if( evt_test_memcpy_attempts_before_fail != -1 )
++ {
++ evt_test_memcpy_attempts_before_fail = -1;
++ }
++ else
++ {
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++ }
++ }
++#endif /* defined( OPTIMIZATION_DISABLED ) */
++#endif /* defined( HAVE_EVT_TEST_MEMORY ) */
++
++ /* Test error case where signature is invalid
++ */
++ byte_stream_copy_from_uint32_little_endian(
++ &( evt_test_event_record_data1[ 4 ] ),
++ 0xffffffffUL );
++
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ 144,
++ &error );
++
++ byte_stream_copy_from_uint32_little_endian(
++ &( evt_test_event_record_data1[ 4 ] ),
++ 0x654c664cUL );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ /* TODO test error case where user security identifier offset and size are out of bounds */
++
++ /* TODO test error case where strings offset and size are out of bounds */
++
++ /* TODO test error case where data offset and size are out of bounds */
++
++ /* Clean up
++ */
++ result = libevt_event_record_free(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ if( event_record != NULL )
++ {
++ libevt_event_record_free(
++ &event_record,
++ NULL );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_record_number function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_record_number(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ uint32_t record_number = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_record_number(
++ event_record,
++ &record_number,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_UINT32(
++ ""record_number"",
++ record_number,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_record_number(
++ NULL,
++ &record_number,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_record_number(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_creation_time function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_creation_time(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ uint32_t posix_time = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_creation_time(
++ event_record,
++ &posix_time,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_UINT32(
++ ""posix_time"",
++ posix_time,
++ 1289437817 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_creation_time(
++ NULL,
++ &posix_time,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_creation_time(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_last_written_time function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_last_written_time(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ uint32_t posix_time = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_last_written_time(
++ event_record,
++ &posix_time,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_UINT32(
++ ""posix_time"",
++ posix_time,
++ 1289437817 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_last_written_time(
++ NULL,
++ &posix_time,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_last_written_time(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_event_identifier function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_event_identifier(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ uint32_t event_identifier = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_event_identifier(
++ event_record,
++ &event_identifier,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_UINT32(
++ ""event_identifier"",
++ event_identifier,
++ 1073742824 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_event_identifier(
++ NULL,
++ &event_identifier,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_event_identifier(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_event_type function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_event_type(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ uint16_t event_type = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_event_type(
++ event_record,
++ &event_type,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_UINT16(
++ ""event_type"",
++ event_type,
++ 4 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_event_type(
++ NULL,
++ &event_type,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_event_type(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_event_category function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_event_category(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ uint16_t event_category = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_event_category(
++ event_record,
++ &event_category,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_UINT16(
++ ""event_category"",
++ event_category,
++ 0 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_event_category(
++ NULL,
++ &event_category,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_event_category(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_source_name_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_source_name_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf8_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_source_name_size(
++ event_record,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_SIZE(
++ ""utf8_string_size"",
++ utf8_string_size,
++ (size_t) 9 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_source_name_size(
++ NULL,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_source_name_size(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_source_name function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_source_name(
++ libevt_event_record_t *event_record )
++{
++ uint8_t utf8_string[ 32 ];
++
++ uint8_t expected_utf8_string[ 9 ] = {
++ 'L', 'o', 'a', 'd', 'P', 'e', 'r', 'f', 0 };
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_source_name(
++ event_record,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = memory_compare(
++ utf8_string,
++ expected_utf8_string,
++ 9 );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_source_name(
++ NULL,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_source_name(
++ event_record,
++ NULL,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_source_name(
++ event_record,
++ utf8_string,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_source_name(
++ event_record,
++ utf8_string,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_source_name_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_source_name_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf16_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_source_name_size(
++ event_record,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_SIZE(
++ ""utf16_string_size"",
++ utf16_string_size,
++ (size_t) 9 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_source_name_size(
++ NULL,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_source_name_size(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_source_name function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_source_name(
++ libevt_event_record_t *event_record )
++{
++ uint16_t utf16_string[ 32 ];
++
++ uint16_t expected_utf16_string[ 9 ] = {
++ 'L', 'o', 'a', 'd', 'P', 'e', 'r', 'f', 0 };
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_source_name(
++ event_record,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = memory_compare(
++ utf16_string,
++ expected_utf16_string,
++ 9 );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_source_name(
++ NULL,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_source_name(
++ event_record,
++ NULL,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_source_name(
++ event_record,
++ utf16_string,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_source_name(
++ event_record,
++ utf16_string,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_computer_name_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_computer_name_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf8_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_computer_name_size(
++ event_record,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_SIZE(
++ ""utf8_string_size"",
++ utf8_string_size,
++ (size_t) 15 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_computer_name_size(
++ NULL,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_computer_name_size(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_computer_name function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_computer_name(
++ libevt_event_record_t *event_record )
++{
++ uint8_t utf8_string[ 32 ];
++
++ uint8_t expected_utf8_string[ 15 ] = {
++ 'W', 'K', 'S', '-', 'W', 'I', 'N', 'X', 'P', '3', '2', 'B', 'I', 'T', 0 };
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_computer_name(
++ event_record,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = memory_compare(
++ utf8_string,
++ expected_utf8_string,
++ 15 );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_computer_name(
++ NULL,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_computer_name(
++ event_record,
++ NULL,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_computer_name(
++ event_record,
++ utf8_string,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_computer_name(
++ event_record,
++ utf8_string,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_computer_name_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_computer_name_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf16_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_computer_name_size(
++ event_record,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_SIZE(
++ ""utf16_string_size"",
++ utf16_string_size,
++ (size_t) 15 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_computer_name_size(
++ NULL,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_computer_name_size(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_computer_name function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_computer_name(
++ libevt_event_record_t *event_record )
++{
++ uint16_t utf16_string[ 32 ];
++
++ uint16_t expected_utf16_string[ 15 ] = {
++ 'W', 'K', 'S', '-', 'W', 'I', 'N', 'X', 'P', '3', '2', 'B', 'I', 'T', 0 };
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_computer_name(
++ event_record,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = memory_compare(
++ utf16_string,
++ expected_utf16_string,
++ 15 );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_computer_name(
++ NULL,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_computer_name(
++ event_record,
++ NULL,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_computer_name(
++ event_record,
++ utf16_string,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_computer_name(
++ event_record,
++ utf16_string,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_user_security_identifier_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_user_security_identifier_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf8_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_user_security_identifier_size(
++ event_record,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_user_security_identifier_size(
++ NULL,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_user_security_identifier function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_user_security_identifier(
++ libevt_event_record_t *event_record )
++{
++ uint8_t utf8_string[ 32 ];
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_user_security_identifier(
++ event_record,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_user_security_identifier(
++ NULL,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_user_security_identifier_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_user_security_identifier_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf16_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_user_security_identifier_size(
++ event_record,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_user_security_identifier_size(
++ NULL,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_user_security_identifier function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_user_security_identifier(
++ libevt_event_record_t *event_record )
++{
++ uint16_t utf16_string[ 32 ];
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_user_security_identifier(
++ event_record,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_user_security_identifier(
++ NULL,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_number_of_strings function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_number_of_strings(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ int number_of_strings = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_number_of_strings(
++ event_record,
++ &number_of_strings,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_UINT16(
++ ""number_of_strings"",
++ number_of_strings,
++ 2 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_number_of_strings(
++ NULL,
++ &number_of_strings,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_number_of_strings(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_string_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_string_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf8_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_string_size(
++ event_record,
++ 0,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_SIZE(
++ ""utf8_string_size"",
++ utf8_string_size,
++ (size_t) 5 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_string_size(
++ NULL,
++ 0,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_string_size(
++ event_record,
++ -1,
++ &utf8_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_string_size(
++ event_record,
++ 0,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf8_string function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf8_string(
++ libevt_event_record_t *event_record )
++{
++ uint8_t utf8_string[ 32 ];
++
++ uint8_t expected_utf8_string[ 5 ] = {
++ 'R', 'S', 'V', 'P', 0 };
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf8_string(
++ event_record,
++ 0,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = memory_compare(
++ utf8_string,
++ expected_utf8_string,
++ 5 );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf8_string(
++ NULL,
++ 0,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_string(
++ event_record,
++ -1,
++ utf8_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_string(
++ event_record,
++ 0,
++ NULL,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_string(
++ event_record,
++ 0,
++ utf8_string,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf8_string(
++ event_record,
++ 0,
++ utf8_string,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_string_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_string_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t utf16_string_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_string_size(
++ event_record,
++ 0,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_SIZE(
++ ""utf16_string_size"",
++ utf16_string_size,
++ (size_t) 5 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_string_size(
++ NULL,
++ 0,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_string_size(
++ event_record,
++ -1,
++ &utf16_string_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_string_size(
++ event_record,
++ 0,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_utf16_string function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_utf16_string(
++ libevt_event_record_t *event_record )
++{
++ uint16_t utf16_string[ 32 ];
++
++ uint16_t expected_utf16_string[ 5 ] = {
++ 'R', 'S', 'V', 'P', 0 };
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_utf16_string(
++ event_record,
++ 0,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = memory_compare(
++ utf16_string,
++ expected_utf16_string,
++ 5 );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_utf16_string(
++ NULL,
++ 0,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_string(
++ event_record,
++ -1,
++ utf16_string,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_string(
++ event_record,
++ 0,
++ NULL,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_string(
++ event_record,
++ 0,
++ utf16_string,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_utf16_string(
++ event_record,
++ 0,
++ utf16_string,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_data_size function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_data_size(
++ libevt_event_record_t *event_record )
++{
++ libcerror_error_t *error = NULL;
++ size_t data_size = 0;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_data_size(
++ event_record,
++ &data_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_EQUAL_SIZE(
++ ""data_size"",
++ data_size,
++ (size_t) 4 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_data_size(
++ NULL,
++ &data_size,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_data_size(
++ event_record,
++ NULL,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++/* Tests the libevt_event_record_get_data function
++ * Returns 1 if successful or 0 if not
++ */
++int evt_test_event_record_get_data(
++ libevt_event_record_t *event_record )
++{
++ uint8_t data[ 32 ];
++
++ uint8_t expected_data[ 4 ] = {
++ 0x0c, 0x14, 0x00, 0x00 };
++
++ libcerror_error_t *error = NULL;
++ int result = 0;
++
++ /* Test regular cases
++ */
++ result = libevt_event_record_get_data(
++ event_record,
++ data,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = memory_compare(
++ data,
++ expected_data,
++ 4 );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 0 );
++
++ /* Test error cases
++ */
++ result = libevt_event_record_get_data(
++ NULL,
++ data,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_data(
++ event_record,
++ NULL,
++ 32,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_data(
++ event_record,
++ data,
++ (size_t) SSIZE_MAX + 1,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ result = libevt_event_record_get_data(
++ event_record,
++ data,
++ 0,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ return( 1 );
++
++on_error:
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ return( 0 );
++}
++
++#endif /* defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT ) */
++
++/* The main program
++ */
++#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
++int wmain(
++ int argc EVT_TEST_ATTRIBUTE_UNUSED,
++ wchar_t * const argv[] EVT_TEST_ATTRIBUTE_UNUSED )
++#else
++int main(
++ int argc EVT_TEST_ATTRIBUTE_UNUSED,
++ char * const argv[] EVT_TEST_ATTRIBUTE_UNUSED )
++#endif
++{
++#if defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT )
++
++ libcerror_error_t *error = NULL;
++ libevt_event_record_t *event_record = NULL;
++ int result = 0;
++
++#endif /* defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT ) */
++
++ EVT_TEST_UNREFERENCED_PARAMETER( argc )
++ EVT_TEST_UNREFERENCED_PARAMETER( argv )
++
++#if defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT )
++
++ EVT_TEST_RUN(
++ ""libevt_event_record_initialize"",
++ evt_test_event_record_initialize );
++
++ EVT_TEST_RUN(
++ ""libevt_event_record_free"",
++ evt_test_event_record_free );
++
++ EVT_TEST_RUN(
++ ""libevt_event_record_read_data"",
++ evt_test_event_record_read_data );
++
++#if !defined( __BORLANDC__ ) || ( __BORLANDC__ >= 0x0560 )
++
++ /* Initialize test
++ */
++ result = libevt_event_record_initialize(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ result = libevt_event_record_read_data(
++ event_record,
++ evt_test_event_record_data1,
++ 144,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_record_number"",
++ evt_test_event_record_get_record_number,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_creation_time"",
++ evt_test_event_record_get_creation_time,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_last_written_time"",
++ evt_test_event_record_get_last_written_time,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_event_identifier"",
++ evt_test_event_record_get_event_identifier,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_event_type"",
++ evt_test_event_record_get_event_type,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_event_category"",
++ evt_test_event_record_get_event_category,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_source_name_size"",
++ evt_test_event_record_get_utf8_source_name_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_source_name"",
++ evt_test_event_record_get_utf8_source_name,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_source_name_size"",
++ evt_test_event_record_get_utf16_source_name_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_source_name"",
++ evt_test_event_record_get_utf16_source_name,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_computer_name_size"",
++ evt_test_event_record_get_utf8_computer_name_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_computer_name"",
++ evt_test_event_record_get_utf8_computer_name,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_computer_name_size"",
++ evt_test_event_record_get_utf16_computer_name_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_computer_name"",
++ evt_test_event_record_get_utf16_computer_name,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_user_security_identifier_size"",
++ evt_test_event_record_get_utf8_user_security_identifier_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_user_security_identifier"",
++ evt_test_event_record_get_utf8_user_security_identifier,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_user_security_identifier_size"",
++ evt_test_event_record_get_utf16_user_security_identifier_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_user_security_identifier"",
++ evt_test_event_record_get_utf16_user_security_identifier,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_number_of_strings"",
++ evt_test_event_record_get_number_of_strings,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_string_size"",
++ evt_test_event_record_get_utf8_string_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf8_string"",
++ evt_test_event_record_get_utf8_string,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_string_size"",
++ evt_test_event_record_get_utf16_string_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_utf16_string"",
++ evt_test_event_record_get_utf16_string,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_data_size"",
++ evt_test_event_record_get_data_size,
++ event_record );
++
++ EVT_TEST_RUN_WITH_ARGS(
++ ""libevt_event_record_get_data"",
++ evt_test_event_record_get_data,
++ event_record );
++
++ /* Clean up
++ */
++ result = libevt_event_record_free(
++ &event_record,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""event_record"",
++ event_record );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++#endif /* !defined( __BORLANDC__ ) || ( __BORLANDC__ >= 0x0560 ) */
++#endif /* defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT ) */
++
++ return( EXIT_SUCCESS );
++
++on_error:
++#if defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT )
++
++ if( error != NULL )
++ {
++ libcerror_error_free(
++ &error );
++ }
++ if( event_record != NULL )
++ {
++ libevt_event_record_free(
++ &event_record,
++ NULL );
++ }
++#endif /* defined( __GNUC__ ) && !defined( LIBEVT_DLL_IMPORT ) */
++
++ return( EXIT_FAILURE );
++}
++
+diff --git a/tests/evt_test_file_header.c b/tests/evt_test_file_header.c
+index 937f7da..e3ca341 100644
+--- a/tests/evt_test_file_header.c
++++ b/tests/evt_test_file_header.c
+@@ -398,6 +398,34 @@ int evt_test_file_header_read_data(
+ libcerror_error_free(
+ &error );
+
++ /* Test error case where signature is invalid
++ */
++ byte_stream_copy_from_uint32_little_endian(
++ &( evt_test_file_header_data1[ 4 ] ),
++ 0xffffffffUL );
++
++ result = libevt_file_header_read_data(
++ file_header,
++ evt_test_file_header_data1,
++ 0,
++ &error );
++
++ byte_stream_copy_from_uint32_little_endian(
++ &( evt_test_file_header_data1[ 4 ] ),
++ 0x654c664cUL );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
+ /* Clean up
+ */
+ result = libevt_file_header_free(
+diff --git a/tests/evt_test_strings_array.c b/tests/evt_test_strings_array.c
+index efd5a3a..f502319 100644
+--- a/tests/evt_test_strings_array.c
++++ b/tests/evt_test_strings_array.c
+@@ -320,6 +320,64 @@ int evt_test_strings_array_read_data(
+ ""error"",
+ error );
+
++ /* Test error cases
++ */
++ result = libevt_strings_array_read_data(
++ strings_array,
++ evt_test_strings_array_data1,
++ 28,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
++ /* Clean up
++ */
++ result = libevt_strings_array_free(
++ &strings_array,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""strings_array"",
++ strings_array );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
++ /* Initialize test
++ */
++ result = libevt_strings_array_initialize(
++ &strings_array,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ 1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""strings_array"",
++ strings_array );
++
++ EVT_TEST_ASSERT_IS_NULL(
++ ""error"",
++ error );
++
+ /* Test error cases
+ */
+ result = libevt_strings_array_read_data(
+@@ -394,6 +452,24 @@ int evt_test_strings_array_read_data(
+ libcerror_error_free(
+ &error );
+
++ result = libevt_strings_array_read_data(
++ strings_array,
++ evt_test_strings_array_data1,
++ 27,
++ &error );
++
++ EVT_TEST_ASSERT_EQUAL_INT(
++ ""result"",
++ result,
++ -1 );
++
++ EVT_TEST_ASSERT_IS_NOT_NULL(
++ ""error"",
++ error );
++
++ libcerror_error_free(
++ &error );
++
+ /* Clean up
+ */
+ result = libevt_strings_array_free(
+diff --git a/tests/test_library.ps1 b/tests/test_library.ps1
+index b6a27be..c3bf12d 100644
+--- a/tests/test_library.ps1
++++ b/tests/test_library.ps1
+@@ -6,7 +6,7 @@ $ExitSuccess = 0
+ $ExitFailure = 1
+ $ExitIgnore = 77
+
+-$LibraryTests = ""end_of_file_record error file_header io_handle notify record record_values strings_array""
++$LibraryTests = ""end_of_file_record error event_record file_header io_handle notify record record_values strings_array""
+ $LibraryTestsWithInput = ""file support""
+
+ $InputGlob = ""*""
+diff --git a/tests/test_library.sh b/tests/test_library.sh
+index 8a3fbf9..8e0afe2 100755
+--- a/tests/test_library.sh
++++ b/tests/test_library.sh
+@@ -7,7 +7,7 @@ EXIT_SUCCESS=0;
+ EXIT_FAILURE=1;
+ EXIT_IGNORE=77;
+
+-LIBRARY_TESTS=""end_of_file_record error file_header io_handle notify record record_values strings_array"";
++LIBRARY_TESTS=""end_of_file_record error event_record file_header io_handle notify record record_values strings_array"";
+ LIBRARY_TESTS_WITH_INPUT=""file support"";
+ OPTION_SETS="""";
+
+",0
+71e60997257dac1720b71c104d2ccc4b7055545c,https://github.com/fosnola/libstaroffice/commit/71e60997257dac1720b71c104d2ccc4b7055545c,ofz#5528 fix signed integer overflow,"diff --git a/src/lib/STOFFOLEParser.cxx b/src/lib/STOFFOLEParser.cxx
+index 0c8f32a..d0db3f4 100644
+--- a/src/lib/STOFFOLEParser.cxx
++++ b/src/lib/STOFFOLEParser.cxx
+@@ -496,7 +496,7 @@ bool STOFFOLEParser::readSummaryInformation(STOFFInputStreamPtr input, std::stri
+ auto depl=int(input->readULong(4));
+ if (depl==0) continue;
+ f << std::hex << depl << std::dec << "":"" << type << "","";
+- if (depl<8+8*N || depl+4>pSetSize || posToTypeMap.find(pos+depl)!=posToTypeMap.end()) {
++ if (depl<8+8*N || depl>pSetSize-4 || posToTypeMap.find(pos+depl)!=posToTypeMap.end()) {
+ f << ""###"";
+ continue;
+ }
+",0
+8be25e611a75c758ad05d36f30e1bebb296f78a9,https://github.com/InvoicePlane/InvoicePlane/commit/8be25e611a75c758ad05d36f30e1bebb296f78a9,"Add logo as .svg, update the readme","diff --git a/README.md b/README.md
+index 7f6142e67..47ed5d5ee 100755
+--- a/README.md
++++ b/README.md
+@@ -1,12 +1,12 @@
+
+-
++
+
+
+
+
+
+-
+-
++
++
+
+
+ InvoicePlane is a self-hosted open source application for managing your invoices, clients and payments.
+@@ -55,7 +55,6 @@ Please notice that InvoicePlane is **not** a commercial software but a small ope
+ [](https://community.invoiceplane.com/)
+ [](https://invoiceplane-slack.herokuapp.com/)
+ [](https://development.invoiceplane.com/)
+-[](https://go.invoiceplane.com/roadmapv1)
+ [](CONTRIBUTING.md)
+
+ ---
+diff --git a/assets/core/img/logo.svg b/assets/core/img/logo.svg
+new file mode 100644
+index 000000000..9ce27e1f9
+--- /dev/null
++++ b/assets/core/img/logo.svg
+@@ -0,0 +1,12 @@
++
++
++ InvoicePlane
++
++
++
++
++
++
++
++
++
+\ No newline at end of file
+",0
+ff7c1d8aaa3afb64dc720c354f154770fd617e03,https://github.com/tikiorg/tiki/commit/ff7c1d8aaa3afb64dc720c354f154770fd617e03,"[REF] Add FIXME for homepage creation with feature_wysiwyg enabled
+
+git-svn-id: https://svn.code.sf.net/p/tikiwiki/code/trunk@64714 b456876b-0849-0410-b77d-98878d47e9d5","diff --git a/lib/setup/wiki.php b/lib/setup/wiki.php
+index 815a108928..5ab1ceb4da 100644
+--- a/lib/setup/wiki.php
++++ b/lib/setup/wiki.php
+@@ -69,6 +69,7 @@
+ if (($prefs['feature_wysiwyg'] === 'y') && $prefs['wysiwyg_htmltowiki'] !== 'y') {
+ $is_html = true;
+
++ // FIXME: Still relies on wiki syntax not parsed, in particular if wysiwyg_wiki_parsed is disabled
+ $homePageContent .= '' . tr('Congratulations') . "" \n"";
+ $homePageContent .= tr('This is the default homepage for your Tiki. If you are seeing this page, your installation was successful.') . ""\n\n "";
+ $homePageContent .= tr('You can change this page after logging in. Please review the [http://doc.tiki.org/wiki+syntax|wiki syntax] for editing details.') . ""\n\n\n "";
+",0
+bb9195f1dd30f51ed973024cbed8e087205749fc,https://github.com/pulp/pulp/commit/bb9195f1dd30f51ed973024cbed8e087205749fc,"Merge pull request #3968 from nathanegillett/non-fastforward-for-new-repos
+
+If repository hasn't been published before, publish without fast-foward","diff --git a/devel/pulp/devel/mock_distributor.py b/devel/pulp/devel/mock_distributor.py
+index 9b62795e36..9e31c04e0f 100644
+--- a/devel/pulp/devel/mock_distributor.py
++++ b/devel/pulp/devel/mock_distributor.py
+@@ -6,7 +6,7 @@
+
+
+ def get_publish_conduit(type_id=None, existing_units=None, pkg_dir=None, checksum_type=""sha"",
+- repodata=None):
++ repodata=None, last_published=None):
+ def build_success_report(summary, details):
+ return PublishReport(True, summary, details)
+
+@@ -58,6 +58,7 @@ def get_scratchpad():
+ publish_conduit.build_success_report = build_success_report
+ publish_conduit.get_repo_scratchpad.side_effect = get_repo_scratchpad
+ publish_conduit.get_scratchpad.side_effect = get_scratchpad
++ publish_conduit.last_published = last_published
+ return publish_conduit
+
+
+diff --git a/server/pulp/plugins/file/distributor.py b/server/pulp/plugins/file/distributor.py
+index 2479938aa1..25f8bd14ca 100644
+--- a/server/pulp/plugins/file/distributor.py
++++ b/server/pulp/plugins/file/distributor.py
+@@ -71,7 +71,7 @@ def publish_repo(self, repo, publish_conduit, config):
+ :rtype: pulp.plugins.model.PublishReport
+ """"""
+ _logger.info(_('Beginning publish for repository <%(repo)s>') % {'repo': repo.id})
+- if not config.get(""force_full"", False):
++ if not config.get(""force_full"", False) and publish_conduit.last_published:
+ try:
+ return self.publish_repo_fast_forward(repo, publish_conduit, config)
+ except FastForwardUnavailable:
+diff --git a/server/test/unit/plugins/file/test_distributor.py b/server/test/unit/plugins/file/test_distributor.py
+index 2ae1245301..59ed810971 100644
+--- a/server/test/unit/plugins/file/test_distributor.py
++++ b/server/test/unit/plugins/file/test_distributor.py
+@@ -234,7 +234,10 @@ def test_publish_repo_bson_doc_too_large(self, mock_get_working, force_full=Fals
+ cloned_unit.unit_key['name'] = ""foo%d.rpm"" % (i)
+ cloned_unit.unit_key['checksum'] = ""sum%s"" % (1000000000 + i)
+ units.append(cloned_unit)
+- new_conduit = get_publish_conduit(existing_units=units)
++ new_conduit = get_publish_conduit(
++ existing_units=units,
++ last_published=""2019-12-05 19:40:26.284627""
++ )
+ distributor.publish_repo(self.repo, new_conduit, PluginCallConfiguration({}, {}, {}))
+ # Verify if do publish with force full after trying with fast forward
+ self.assertEqual(distributor.get_hosting_locations.call_count, 3)
+@@ -245,7 +248,10 @@ def test_publish_repo_bson_doc_too_large(self, mock_get_working, force_full=Fals
+ cloned_unit.unit_key['name'] = ""fooa%d.rpm"" % (i)
+ cloned_unit.unit_key['checksum'] = ""suma%s"" % (1000000000 + i)
+ units.append(cloned_unit)
+- new_conduit = get_publish_conduit(existing_units=units)
++ new_conduit = get_publish_conduit(
++ existing_units=units,
++ last_published=""2019-12-05 19:40:26.284627""
++ )
+ distributor.publish_repo(self.repo, new_conduit, PluginCallConfiguration({}, {}, {}))
+ # Verify if do publish with fast forward
+ self.assertEqual(distributor.get_hosting_locations.call_count, 4)
+@@ -266,7 +272,10 @@ def test_publish_repo_way_by_conditions(self, mock_get_working):
+ cloned_unit.unit_key['name'] = ""foo%d.rpm"" % (i)
+ cloned_unit.unit_key['checksum'] = ""sum%s"" % (1000000000 + i)
+ units.append(cloned_unit)
+- new_conduit = get_publish_conduit(existing_units=units)
++ new_conduit = get_publish_conduit(
++ existing_units=units,
++ last_published=""2019-12-05 19:40:26.284627""
++ )
+ distributor.publish_repo(self.repo, new_conduit, PluginCallConfiguration({}, {}, {}))
+ # Verify if do publish with force full finally after trying with fast forward
+ self.assertEqual(distributor.get_hosting_locations.call_count, 3)
+@@ -277,7 +286,10 @@ def test_publish_repo_way_by_conditions(self, mock_get_working):
+ cloned_unit.unit_key['name'] = ""food%d.rpm"" % (i)
+ cloned_unit.unit_key['checksum'] = ""sumd%s"" % (1000000000 + i)
+ units.append(cloned_unit)
+- new_conduit = get_publish_conduit(existing_units=units)
++ new_conduit = get_publish_conduit(
++ existing_units=units,
++ last_published=""2019-12-05 19:40:26.284627""
++ )
+ distributor.publish_repo(self.repo, new_conduit, PluginCallConfiguration({}, {}, {}))
+ # Verify if do publish with fast forward
+ self.assertEqual(distributor.get_hosting_locations.call_count, 4)
+",0
+0a75334fad443e3406b82c5a3cea54e082549440,https://github.com/undertow-io/undertow/commit/0a75334fad443e3406b82c5a3cea54e082549440,[UNDERTOW-1817] Enhance error page handling to be spec compliant,"diff --git a/servlet/src/main/java/io/undertow/servlet/spec/RequestDispatcherImpl.java b/servlet/src/main/java/io/undertow/servlet/spec/RequestDispatcherImpl.java
+index 232bcc6a11..8bbbbf0790 100644
+--- a/servlet/src/main/java/io/undertow/servlet/spec/RequestDispatcherImpl.java
++++ b/servlet/src/main/java/io/undertow/servlet/spec/RequestDispatcherImpl.java
+@@ -467,8 +467,13 @@ private void error(ServletRequestContext servletRequestContext, final ServletReq
+ requestImpl.setAttribute(ERROR_REQUEST_URI, requestImpl.getRequestURI());
+ requestImpl.setAttribute(ERROR_SERVLET_NAME, servletName);
+ if (exception != null) {
+- requestImpl.setAttribute(ERROR_EXCEPTION, exception);
+- requestImpl.setAttribute(ERROR_EXCEPTION_TYPE, exception.getClass());
++ if (exception instanceof ServletException && ((ServletException)exception).getRootCause() != null) {
++ requestImpl.setAttribute(ERROR_EXCEPTION, ((ServletException) exception).getRootCause());
++ requestImpl.setAttribute(ERROR_EXCEPTION_TYPE, ((ServletException) exception).getRootCause().getClass());
++ } else {
++ requestImpl.setAttribute(ERROR_EXCEPTION, exception);
++ requestImpl.setAttribute(ERROR_EXCEPTION_TYPE, exception.getClass());
++ }
+ }
+ requestImpl.setAttribute(ERROR_MESSAGE, message);
+ requestImpl.setAttribute(ERROR_STATUS_CODE, responseImpl.getStatus());
+diff --git a/servlet/src/test/java/io/undertow/servlet/test/errorpage/ErrorPageTestCase.java b/servlet/src/test/java/io/undertow/servlet/test/errorpage/ErrorPageTestCase.java
+index 2f81b8ad15..e0f30f232b 100644
+--- a/servlet/src/test/java/io/undertow/servlet/test/errorpage/ErrorPageTestCase.java
++++ b/servlet/src/test/java/io/undertow/servlet/test/errorpage/ErrorPageTestCase.java
+@@ -239,8 +239,8 @@ private void runTest(int deploymentNo, final TestHttpClient client, Integer stat
+ // RequestDispatcher.ERROR_MESSAGE is null
+ Assert.assertThat(response, CoreMatchers.containsString(RequestDispatcher.ERROR_STATUS_CODE + ""=500""));
+ } else {
+- Assert.assertThat(response, CoreMatchers.containsString(RequestDispatcher.ERROR_EXCEPTION_TYPE + ""="" + ServletException.class));
+- Assert.assertThat(response, CoreMatchers.containsString(RequestDispatcher.ERROR_EXCEPTION + ""=javax.servlet.ServletException: "" + exception.getName()));
++ Assert.assertThat(response, CoreMatchers.containsString(RequestDispatcher.ERROR_EXCEPTION_TYPE + ""="" + exception));
++ Assert.assertThat(response, CoreMatchers.containsString(RequestDispatcher.ERROR_EXCEPTION + ""="" + exception.getName()));
+ Assert.assertThat(response, CoreMatchers.containsString(RequestDispatcher.ERROR_MESSAGE + ""="" + exception.getName()));
+ Assert.assertThat(response, CoreMatchers.containsString(RequestDispatcher.ERROR_STATUS_CODE + ""=500""));
+ }
+",0
+850a113226e21d376a6c227f9ff5c972f071fdac,https://github.com/apache/derby/commit/850a113226e21d376a6c227f9ff5c972f071fdac,"DERBY-7020: Make the release machinery pick up the current min.version value so that the generated user docs will report the correct minimum JDK version; commit derby-7020-02-aa-fixMinJDKVersionInDocs.diff.
+
+git-svn-id: https://svn.apache.org/repos/asf/db/derby/code/trunk@1847661 13f79535-47bb-0310-9956-ffa450edef68","diff --git a/build.xml b/build.xml
+index edf4c752df..d8ca17d505 100644
+--- a/build.xml
++++ b/build.xml
+@@ -2033,6 +2033,7 @@
+
+
+
++
+
+
+
+",0
+665226ae14a0f0a04a09cf53198b77fd09c16f14,https://github.com/jenkinsci/kubernetes-plugin/commit/665226ae14a0f0a04a09cf53198b77fd09c16f14,"Merge pull request #934 from jenkinsci/dependabot/maven/io.jenkins.tools.bom-bom-2.263.x-21
+
+Bump bom-2.263.x from 20 to 21","diff --git a/pom.xml b/pom.xml
+index 13cef23b47..9f2fd9fd55 100644
+--- a/pom.xml
++++ b/pom.xml
+@@ -256,7 +256,7 @@
+
+ io.jenkins.tools.bom
+ bom-2.263.x
+- 20
++ 21
+ import
+ pom
+
+",0
+0909d301705f197d0e62efacae7e65b534da46d5,https://github.com/apache/santuario-java/commit/0909d301705f197d0e62efacae7e65b534da46d5,"Add methods to remove References.
+
+git-svn-id: https://svn.apache.org/repos/asf/santuario/trunk@1027337 13f79535-47bb-0310-9956-ffa450edef68","diff --git a/c/CHANGELOG.txt b/c/CHANGELOG.txt
+index e2ae9e45d..bbe364ca4 100644
+--- a/c/CHANGELOG.txt
++++ b/c/CHANGELOG.txt
+@@ -20,6 +20,7 @@ Changes since 1.5.1
+ * Support debugging of Reference/SignedInfo data (SC)
+ * Clean up tests for SHA2 algorithms in OpenSSL (SC)
+ * Updated autoconf script, added NSS support, removed pre-automake material (SC)
++* Add methods for Reference removal to DSIGSignature/DSIGSignedInfo classes (SC)
+
+ Changes between 1.5 and 1.5.1
+ =====================================
+diff --git a/c/xsec/dsig/DSIGReference.hpp b/c/xsec/dsig/DSIGReference.hpp
+index 59bba8c04..4e6689fe1 100644
+--- a/c/xsec/dsig/DSIGReference.hpp
++++ b/c/xsec/dsig/DSIGReference.hpp
+@@ -45,6 +45,7 @@ class DSIGTransformXPath;
+ class DSIGTransformXPathFilter;
+ class DSIGTransformXSL;
+ class DSIGSignature;
++class DSIGSignedInfo;
+
+ class TXFMBase;
+ class TXFMChain;
+@@ -569,6 +570,8 @@ class DSIG_EXPORT DSIGReference {
+ DSIGReference();
+
+ /*\@}*/
++
++ friend class DSIGSignedInfo;
+ };
+
+
+diff --git a/c/xsec/dsig/DSIGSignature.cpp b/c/xsec/dsig/DSIGSignature.cpp
+index 463494efc..86a275008 100644
+--- a/c/xsec/dsig/DSIGSignature.cpp
++++ b/c/xsec/dsig/DSIGSignature.cpp
+@@ -699,6 +699,10 @@ DSIGReference * DSIGSignature::createReference(
+
+ }
+
++DSIGReference * DSIGSignature::removeReference(DSIGReferenceList::size_type index) {
++ return mp_signedInfo ? mp_signedInfo->removeReference(index) : NULL;
++}
++
+ // --------------------------------------------------------------------------------
+ // Manipulation of KeyInfo elements
+ // --------------------------------------------------------------------------------
+diff --git a/c/xsec/dsig/DSIGSignature.hpp b/c/xsec/dsig/DSIGSignature.hpp
+index e993bc773..276d17cc3 100644
+--- a/c/xsec/dsig/DSIGSignature.hpp
++++ b/c/xsec/dsig/DSIGSignature.hpp
+@@ -390,6 +390,22 @@ class DSIG_EXPORT DSIGSignature {
+ const XMLCh * hashAlgorithmURI,
+ const XMLCh * type = NULL
+ );
++
++ /**
++ * \brief Remove a reference from the signature
++ *
++ * Removes the reference at the index point and returns a pointer
++ * to the reference removed.
++ *
++ * @note This also releases ownership. It is the responsibility of
++ * the caller to ensure the reference is deleted.
++ *
++ * @note This removes the reference from the Signature
++ *
++ * @param index Point in the list to remove
++ */
++
++ DSIGReference * removeReference(DSIGReferenceList::size_type index);
+ //@}
+
+ /** @name General and Information functions. */
+diff --git a/c/xsec/dsig/DSIGSignedInfo.cpp b/c/xsec/dsig/DSIGSignedInfo.cpp
+index 832abcb39..a69c9da0d 100644
+--- a/c/xsec/dsig/DSIGSignedInfo.cpp
++++ b/c/xsec/dsig/DSIGSignedInfo.cpp
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright 2002-2005 The Apache Software Foundation.
++ * Copyright 2002-2010 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the ""License"");
+ * you may not use this file except in compliance with the License.
+@@ -175,6 +175,18 @@ DSIGReference * DSIGSignedInfo::createReference(
+ return ref;
+ }
+
++DSIGReference * DSIGSignedInfo::removeReference(DSIGReferenceList::size_type index) {
++
++ DSIGReference* ret = mp_referenceList ? mp_referenceList->removeReference(index): NULL;
++ if (ret && mp_signedInfoNode) {
++ mp_signedInfoNode->removeChild(ret->mp_referenceNode);
++ mp_env->doPrettyPrint(mp_signedInfoNode);
++ }
++
++ return ret;
++
++}
++
+
+ // --------------------------------------------------------------------------------
+ // Create an empty SignedInfo
+diff --git a/c/xsec/dsig/DSIGSignedInfo.hpp b/c/xsec/dsig/DSIGSignedInfo.hpp
+index 8c2ac3aa5..fc68e4415 100644
+--- a/c/xsec/dsig/DSIGSignedInfo.hpp
++++ b/c/xsec/dsig/DSIGSignedInfo.hpp
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright 2002-2005 The Apache Software Foundation.
++ * Copyright 2002-2010 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the ""License"");
+ * you may not use this file except in compliance with the License.
+@@ -220,6 +220,22 @@ class DSIG_EXPORT DSIGSignedInfo {
+ const XMLCh * type
+ );
+
++ /**
++ * \brief Remove a reference from the list
++ *
++ * Removes the reference at the index point and returns a pointer
++ * to the reference removed.
++ *
++ * @note This also releases ownership. It is the responsibility of
++ * the caller to ensure the reference is deleted.
++ *
++ * @note This removes the reference from the Signature
++ *
++ * @param index Point in the list to remove
++ */
++
++ DSIGReference * removeReference(DSIGReferenceList::size_type index);
++
+ //@}
+
+ /** @name Getter functions */
+",0
+256a5f9d3eafbc477dcf77c7682446cc4b449c7f,https://github.com/renlok/WeBid/commit/256a5f9d3eafbc477dcf77c7682446cc4b449c7f,Number of secerity fixes & fix for setup fee #510,"diff --git a/active_auctions.php b/active_auctions.php
+index e90c9a4d..2caadddd 100644
+--- a/active_auctions.php
++++ b/active_auctions.php
+@@ -66,7 +66,7 @@
+ $k = 0;
+ while ($row = $db->fetch()) {
+ if (strlen($row['pict_url']) > 0) {
+- $row['pict_url'] = $system->SETTINGS['siteurl'] . 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&fromfile=' . UPLOAD_FOLDER . $row['id'] . '/' . $row['pict_url'];
++ $row['pict_url'] = $system->SETTINGS['siteurl'] . 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&auction_id=' . $row['id'] . '&fromfile=' . $row['pict_url'];
+ } else {
+ $row['pict_url'] = get_lang_img('nopicture.gif');
+ }
+diff --git a/admin/editauction.php b/admin/editauction.php
+index ff16e1c3..26757aa7 100644
+--- a/admin/editauction.php
++++ b/admin/editauction.php
+@@ -36,7 +36,7 @@ function load_gallery($auc_id)
+ if ($dir = opendir(UPLOAD_PATH . $auc_id)) {
+ while ($file = @readdir($dir)) {
+ if ($file != '.' && $file != '..' && strpos($file, 'thumb-') === false) {
+- $UPLOADED_PICTURES[] = UPLOAD_FOLDER . $auc_id . '/' . $file;
++ $UPLOADED_PICTURES[] = $file;
+ }
+ }
+ closedir($dir);
+diff --git a/bid.php b/bid.php
+index 065e96f3..c8eecb25 100644
+--- a/bid.php
++++ b/bid.php
+@@ -561,7 +561,7 @@ function extend_auction($id, $ends)
+ 'ERROR' => (isset($errmsg)) ? $errmsg : '',
+ 'BID_HISTORY' => (isset($ARETHEREBIDS)) ? $ARETHEREBIDS : '',
+ 'ID' => $id,
+- 'IMAGE' => (!empty($pict_url_plain)) ? ' SETTINGS['thumb_show'] . '&fromfile=' . UPLOAD_FOLDER . $id . '/' . $pict_url_plain . '"" border=""0"" align=""center"">' : ' ',
++ 'IMAGE' => (!empty($pict_url_plain)) ? ' SETTINGS['thumb_show'] . '&auction_id=' . $id . '&fromfile=' . $pict_url_plain . '"" border=""0"" align=""center"">' : '',
+ 'TITLE' => $item_title,
+ 'CURRENT_BID' => $system->print_money($cbid),
+ 'ATYPE' => $atype,
+diff --git a/closed_auctions.php b/closed_auctions.php
+index 660bef21..f12a162f 100644
+--- a/closed_auctions.php
++++ b/closed_auctions.php
+@@ -65,7 +65,7 @@
+ $starting_price = $row['current_bid'];
+
+ if (strlen($row['pict_url']) > 0) {
+- $row['pict_url'] = $system->SETTINGS['siteurl'] . 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&fromfile=' . UPLOAD_FOLDER . $row['id'] . '/' . $row['pict_url'];
++ $row['pict_url'] = $system->SETTINGS['siteurl'] . 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&auction_id=' . $row['id'] . '&fromfile=' . $row['pict_url'];
+ } else {
+ $row['pict_url'] = get_lang_img('nopicture.gif');
+ }
+diff --git a/getthumb.php b/getthumb.php
+index 76f753c8..848e835a 100644
+--- a/getthumb.php
++++ b/getthumb.php
+@@ -14,9 +14,31 @@
+
+ include 'common.php';
+
++// get passed values
+ $w = (isset($_GET['w'])) ? intval($_GET['w']) : '';
+-$_w = $w;
+-$fromfile = (isset($_GET['fromfile'])) ? $_GET['fromfile'] : '';
++$fromfile = $_GET['fromfile'];
++$auction_id = $_GET['auction_id'];
++
++// check passed values
++if (!isset($_GET['fromfile']) ||
++ !isset($_GET['auction_id']) || !is_numeric($auction_id)) {
++ ErrorPNG($ERR_716);
++ exit;
++} elseif (!file_exists($_GET['fromfile']) && !fopen($_GET['fromfile'], 'r')) {
++ ErrorPNG($ERR_716);
++ exit;
++}
++
++if ($fromfile != '') {
++ // clean fromfile
++ $fromfile = basename($fromfile);
++ // build file path
++ $file_path = UPLOAD_FOLDER . $auction_id . '/' . $fromfile;
++} else {
++ // if empty filename just show default image
++ $file_path = MAIN_PATH . 'images/email_alerts/default_item_img.jpg';
++}
++
+ $nomanage = false;
+ $accepted_widths = array(
+ $system->SETTINGS['thumb_show'],
+@@ -47,17 +69,8 @@ function load_image($file, $mime, $image_type, $output_type)
+ exit;
+ }
+
+-// control parameters and file existence
+-if (!isset($_GET['fromfile']) || $fromfile == '') {
+- ErrorPNG($ERR_716);
+- exit;
+-} elseif (!file_exists($_GET['fromfile']) && !fopen($_GET['fromfile'], 'r')) {
+- ErrorPNG($ERR_716);
+- exit;
+-}
+-
+ if (file_exists(UPLOAD_PATH . 'cache/' . $w . '-' . md5($fromfile))) {
+- $img = getimagesize($fromfile);
++ $img = getimagesize($file_path);
+ switch ($img[2]) {
+ case IMAGETYPE_GIF:
+ if (!(imagetypes() &IMG_GIF)) {
+@@ -98,7 +111,7 @@ function load_image($file, $mime, $image_type, $output_type)
+ mkdir(UPLOAD_PATH . 'cache', 0777);
+ }
+
+- $img = @getimagesize($fromfile);
++ $img = @getimagesize($file_path);
+ if (is_array($img)) {
+ switch ($img[2]) {
+ case IMAGETYPE_GIF:
+@@ -141,7 +154,7 @@ function load_image($file, $mime, $image_type, $output_type)
+ }
+ if ($w == '') {
+ // just load the image
+- load_image($fromfile, $img['mime'], $image_type, $output_type);
++ load_image($file_path, $img['mime'], $image_type, $output_type);
+ } else {
+ // check image orientation
+ if ($img[0] < $img[1]) {
+@@ -156,9 +169,9 @@ function load_image($file, $mime, $image_type, $output_type)
+ $ou = imagecreatetruecolor($w, $h);
+ imagealphablending($ou, false);
+ $funcall = ""imagecreatefrom$image_type"";
+- imagecopyresampled($ou, $funcall($fromfile), 0, 0, 0, 0, $w, $h, $img[0], $img[1]);
++ imagecopyresampled($ou, $funcall($file_path), 0, 0, 0, 0, $w, $h, $img[0], $img[1]);
+ $funcall = ""image$output_type"";
+- $funcall($ou, UPLOAD_PATH . 'cache/' . $_w . '-' . md5($fromfile));
++ $funcall($ou, UPLOAD_PATH . 'cache/' . $w . '-' . md5($fromfile));
+ header('Content-type: ' . $img['mime']);
+ $funcall($ou);
+ exit;
+diff --git a/includes/browseitems.inc.php b/includes/browseitems.inc.php
+index b7cdf685..341b6def 100644
+--- a/includes/browseitems.inc.php
++++ b/includes/browseitems.inc.php
+@@ -116,7 +116,7 @@ function build_items($row)
+
+ // image icon
+ if (!empty($row['pict_url'])) {
+- $row['pict_url'] = $system->SETTINGS['siteurl'] . 'getthumb.php?w=' . $system->SETTINGS['thumb_list'] . '&fromfile=' . UPLOAD_FOLDER . $row['id'] . '/' . $row['pict_url'];
++ $row['pict_url'] = $system->SETTINGS['siteurl'] . 'getthumb.php?w=' . $system->SETTINGS['thumb_list'] . '&auction_id=' . $row['id'] . '&fromfile=' . $row['pict_url'];
+ } else {
+ $row['pict_url'] = get_lang_img('nopicture.gif');
+ }
+diff --git a/includes/functions_sell.php b/includes/functions_sell.php
+index 08b4c4da..327dcc77 100644
+--- a/includes/functions_sell.php
++++ b/includes/functions_sell.php
+@@ -398,7 +398,7 @@ function get_fee($minimum_bid, $just_fee = true)
+ 'extracat_fee' => 0
+ );
+ while ($row = $db->fetch()) {
+- if ($minimum_bid >= $row['fee_from'] && $minimum_bid <= $row['fee_to'] && $row['type'] == 'setup') {
++ if ($minimum_bid >= $row['fee_from'] && $minimum_bid <= $row['fee_to'] && $row['type'] == 'setup_fee') {
+ if ($row['fee_type'] == 'flat') {
+ $fee_data['setup_fee'] = $row['value'];
+ $fee_value = bcadd($fee_value, $row['value'], $system->SETTINGS['moneydecimals']);
+diff --git a/index.php b/index.php
+index ceace577..994f00ce 100644
+--- a/index.php
++++ b/index.php
+@@ -104,7 +104,7 @@ function ShowFlags()
+ 'ENDS' => $ends_string,
+ 'ID' => $row['id'],
+ 'BID' => $system->print_money($high_bid),
+- 'IMAGE' => (!empty($row['pict_url'])) ? 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&fromfile=' . UPLOAD_FOLDER . $row['id'] . '/' . $row['pict_url'] : 'images/email_alerts/default_item_img.jpg',
++ 'IMAGE' => (!empty($row['pict_url'])) ? 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&auction_id=' . $row['id'] . '&fromfile=' . $row['pict_url'] : '',
+ 'TITLE' => htmlspecialchars($row['title'])
+ ));
+ $i++;
+@@ -188,7 +188,7 @@ function ShowFlags()
+ 'ENDS' => $ends_string,
+ 'ID' => $row['id'],
+ 'BID' => $system->print_money($high_bid),
+- 'IMAGE' => (!empty($row['pict_url'])) ? 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&fromfile=' . UPLOAD_FOLDER . $row['id'] . '/' . $row['pict_url'] : 'images/email_alerts/default_item_img.jpg',
++ 'IMAGE' => (!empty($row['pict_url'])) ? 'getthumb.php?w=' . $system->SETTINGS['thumb_show'] . '&auction_id=' . $row['id'] . '&fromfile=' . $row['pict_url'] : '',
+ 'TITLE' => htmlspecialchars($row['title'])
+ ));
+ }
+diff --git a/item.php b/item.php
+index b1cc285e..b0b768ec 100644
+--- a/item.php
++++ b/item.php
+@@ -466,7 +466,7 @@
+ 'TITLE' => htmlspecialchars($auction_data['title']),
+ 'SUBTITLE' => htmlspecialchars($auction_data['subtitle']),
+ 'AUCTION_DESCRIPTION' => $auction_data['description'],
+- 'PIC_URL' => UPLOAD_FOLDER . $id . '/' . $auction_data['pict_url'],
++ 'PIC_URL' => $auction_data['pict_url'],
+ 'SHIPPING_COST' => ($auction_data['shipping_cost'] > 0) ? $system->print_money($auction_data['shipping_cost']) : $MSG['1152'],
+ 'ADDITIONAL_SHIPPING_COST' => $system->print_money($auction_data['additional_shipping_cost']),
+ 'COUNTRY' => $auction_data['country'],
+diff --git a/register.php b/register.php
+index a5021b23..0f616734 100644
+--- a/register.php
++++ b/register.php
+@@ -448,15 +448,15 @@ function emailDomainIsBlacklisted($email)
+
+ 'V_YNEWSL' => ((isset($_POST['TPL_nletter']) && $_POST['TPL_nletter'] == 1) || !isset($_POST['TPL_nletter'])) ? 'checked=true' : '',
+ 'V_NNEWSL' => (isset($_POST['TPL_nletter']) && $_POST['TPL_nletter'] == 2) ? 'checked=true' : '',
+- 'V_YNAME' => (isset($_POST['TPL_name'])) ? $_POST['TPL_name'] : '',
+- 'V_UNAME' => (isset($_POST['TPL_nick'])) ? $_POST['TPL_nick'] : '',
+- 'V_EMAIL' => (isset($_POST['TPL_email'])) ? $_POST['TPL_email'] : '',
+- 'V_YEAR' => (isset($_POST['TPL_year'])) ? $_POST['TPL_year'] : '',
+- 'V_ADDRE' => (isset($_POST['TPL_address'])) ? $_POST['TPL_address'] : '',
+- 'V_CITY' => (isset($_POST['TPL_city'])) ? $_POST['TPL_city'] : '',
+- 'V_PROV' => (isset($_POST['TPL_prov'])) ? $_POST['TPL_prov'] : '',
+- 'V_POSTCODE' => (isset($_POST['TPL_zip'])) ? $_POST['TPL_zip'] : '',
+- 'V_PHONE' => (isset($_POST['TPL_phone'])) ? $_POST['TPL_phone'] : ''
++ 'V_YNAME' => (isset($_POST['TPL_name'])) ? $system->cleanvars($_POST['TPL_name']) : '',
++ 'V_UNAME' => (isset($_POST['TPL_nick'])) ? $system->cleanvars($_POST['TPL_nick']) : '',
++ 'V_EMAIL' => (isset($_POST['TPL_email'])) ? $system->cleanvars($_POST['TPL_email']) : '',
++ 'V_YEAR' => (isset($_POST['TPL_year'])) ? $system->cleanvars($_POST['TPL_year']) : '',
++ 'V_ADDRE' => (isset($_POST['TPL_address'])) ? $system->cleanvars($_POST['TPL_address']) : '',
++ 'V_CITY' => (isset($_POST['TPL_city'])) ? $system->cleanvars($_POST['TPL_city']) : '',
++ 'V_PROV' => (isset($_POST['TPL_prov'])) ? $system->cleanvars($_POST['TPL_prov']) : '',
++ 'V_POSTCODE' => (isset($_POST['TPL_zip'])) ? $system->cleanvars($_POST['TPL_zip']) : '',
++ 'V_PHONE' => (isset($_POST['TPL_phone'])) ? $system->cleanvars($_POST['TPL_phone']) : ''
+ ));
+
+ include 'header.php';
+diff --git a/themes/adminClassic/editauction.tpl b/themes/adminClassic/editauction.tpl
+index e2d35e40..589ccc18 100644
+--- a/themes/adminClassic/editauction.tpl
++++ b/themes/adminClassic/editauction.tpl
+@@ -71,7 +71,7 @@
+
+
+diff --git a/themes/adminModern/editauction.tpl b/themes/adminModern/editauction.tpl
+index 4e290a7e..c11f7b12 100644
+--- a/themes/adminModern/editauction.tpl
++++ b/themes/adminModern/editauction.tpl
+@@ -71,7 +71,7 @@
+
+
+diff --git a/themes/classic/item.tpl b/themes/classic/item.tpl
+index a573ffc1..14a00b93 100644
+--- a/themes/classic/item.tpl
++++ b/themes/classic/item.tpl
+@@ -81,7 +81,7 @@ $(document).ready(function() {
+
+
+
+-
++
+
+ {L_694}
+
+@@ -308,7 +308,7 @@ $(document).ready(function() {
+
+
+
+-
++
+
+
+
+diff --git a/themes/modern/item.tpl b/themes/modern/item.tpl
+index 25881532..cceba6f3 100644
+--- a/themes/modern/item.tpl
++++ b/themes/modern/item.tpl
+@@ -57,7 +57,7 @@ $(document).ready(function() {
+ {L_113}: {ID}
+
+
+-
++
+
+
+
+@@ -66,7 +66,7 @@ $(document).ready(function() {
+
+
+
+
+diff --git a/user_login.php b/user_login.php
+index ab98569b..8d386c11 100644
+--- a/user_login.php
++++ b/user_login.php
+@@ -124,7 +124,7 @@
+
+ $template->assign_vars(array(
+ 'ERROR' => (isset($ERR)) ? $ERR : '',
+- 'USER' => (isset($_POST['username'])) ? $_POST['username'] : ''
++ 'USER' => (isset($_POST['username'])) ? $system->cleanvars($_POST['username']) : ''
+ ));
+
+ include 'header.php';
+diff --git a/yourauctions.php b/yourauctions.php
+index 53f09125..0a3244bc 100644
+--- a/yourauctions.php
++++ b/yourauctions.php
+@@ -99,8 +99,9 @@
+ $_SESSION['oa_ord'] = 'title';
+ $_SESSION['oa_type'] = 'asc';
+ } elseif (!empty($_GET['oa_ord'])) {
+- $_SESSION['oa_ord'] = $_GET['oa_ord'];
+- $_SESSION['oa_type'] = $_GET['oa_type'];
++ // check oa_ord && oa_type are valid
++ $_SESSION['oa_ord'] = (in_array($_GET['oa_ord'], array('title', 'starts', 'ends', 'num_bids', 'current_bid'))) ? $_GET['oa_ord'] : 'title';
++ $_SESSION['oa_type'] = (in_array($_GET['oa_type'], array('asc', 'desc'))) ? $_GET['oa_type'] : 'asc';
+ } elseif (isset($_SESSION['oa_ord']) && empty($_GET['oa_ord'])) {
+ $_SESSION['oa_nexttype'] = $_SESSION['oa_type'];
+ }
+diff --git a/yourauctions_c.php b/yourauctions_c.php
+index 3d89e1a3..089bc25d 100644
+--- a/yourauctions_c.php
++++ b/yourauctions_c.php
+@@ -204,8 +204,9 @@
+ $_SESSION['ca_ord'] = 'title';
+ $_SESSION['ca_type'] = 'asc';
+ } elseif (!empty($_GET['ca_ord'])) {
+- $_SESSION['ca_ord'] = $_GET['ca_ord'];
+- $_SESSION['ca_type'] = $_GET['ca_type'];
++ // check oa_ord && oa_type are valid
++ $_SESSION['ca_ord'] = (in_array($_GET['ca_ord'], array('title', 'starts', 'ends', 'num_bids', 'current_bid'))) ? $_GET['ca_ord'] : 'title';
++ $_SESSION['ca_type'] = (in_array($_GET['ca_type'], array('asc', 'desc'))) ? $_GET['ca_type'] : 'asc';
+ } elseif (isset($_SESSION['ca_ord']) && empty($_GET['ca_ord'])) {
+ $_SESSION['ca_nexttype'] = $_SESSION['ca_type'];
+ }
+diff --git a/yourauctions_p.php b/yourauctions_p.php
+index 761dfa51..e1770eb3 100644
+--- a/yourauctions_p.php
++++ b/yourauctions_p.php
+@@ -109,8 +109,9 @@
+ $_SESSION['pa_ord'] = 'title';
+ $_SESSION['pa_type'] = 'asc';
+ } elseif (!empty($_GET['pa_ord'])) {
+- $_SESSION['pa_ord'] = $_GET['pa_ord'];
+- $_SESSION['pa_type'] = $_GET['pa_type'];
++ // check oa_ord && oa_type are valid
++ $_SESSION['pa_ord'] = (in_array($_GET['pa_ord'], array('title', 'starts', 'ends'))) ? $_GET['pa_ord'] : 'title';
++ $_SESSION['pa_type'] = (in_array($_GET['pa_type'], array('asc', 'desc'))) ? $_GET['pa_type'] : 'asc';
+ } elseif (isset($_SESSION['pa_ord']) && empty($_GET['pa_ord'])) {
+ $_SESSION['pa_nexttype'] = $_SESSION['pa_type'];
+ }
+diff --git a/yourauctions_s.php b/yourauctions_s.php
+index fa909638..b3343bae 100644
+--- a/yourauctions_s.php
++++ b/yourauctions_s.php
+@@ -81,8 +81,9 @@
+ $_SESSION['sa_ord'] = 'title';
+ $_SESSION['sa_type'] = 'asc';
+ } elseif (!empty($_GET['sa_ord'])) {
+- $_SESSION['sa_ord'] = $_GET['sa_ord'];
+- $_SESSION['sa_type'] = $_GET['sa_type'];
++ // check oa_ord && oa_type are valid
++ $_SESSION['sa_ord'] = (in_array($_GET['sa_ord'], array('title', 'num_bids', 'current_bid'))) ? $_GET['sa_ord'] : 'title';
++ $_SESSION['sa_type'] = (in_array($_GET['sa_type'], array('asc', 'desc'))) ? $_GET['sa_type'] : 'asc';
+ } elseif (isset($_SESSION['sa_ord']) && empty($_GET['sa_ord'])) {
+ $_SESSION['sa_nexttype'] = $_SESSION['sa_type'];
+ }
+diff --git a/yourauctions_sold.php b/yourauctions_sold.php
+index 578e785d..1cf2a08a 100644
+--- a/yourauctions_sold.php
++++ b/yourauctions_sold.php
+@@ -149,8 +149,9 @@
+ $_SESSION['solda_ord'] = 'title';
+ $_SESSION['solda_type'] = 'asc';
+ } elseif (!empty($_GET['solda_ord'])) {
+- $_SESSION['solda_ord'] = $_GET['solda_ord'];
+- $_SESSION['solda_type'] = $_GET['solda_type'];
++ // check oa_ord && oa_type are valid
++ $_SESSION['solda_ord'] = (in_array($_GET['solda_ord'], array('title', 'starts', 'ends', 'num_bids', 'current_bid'))) ? $_GET['solda_ord'] : 'title';
++ $_SESSION['solda_type'] = (in_array($_GET['solda_type'], array('asc', 'desc'))) ? $_GET['solda_type'] : 'asc';
+ } elseif (isset($_SESSION['solda_ord']) && empty($_GET['solda_ord'])) {
+ $_SESSION['solda_nexttype'] = $_SESSION['solda_type'];
+ }
+",1
+5c819f7242fe208f4214d6017e4eb8bf397d60e3,https://github.com/qbittorrent/qBittorrent/commit/5c819f7242fe208f4214d6017e4eb8bf397d60e3,Revise version comparison,"diff --git a/src/gui/programupdater.cpp b/src/gui/programupdater.cpp
+index 6539770c9a..5d813434b9 100644
+--- a/src/gui/programupdater.cpp
++++ b/src/gui/programupdater.cpp
+@@ -36,7 +36,6 @@
+ #include
+ #include
+ #include
+-#include
+ #include
+
+ #if defined(Q_OS_WIN)
+@@ -44,35 +43,32 @@
+ #endif
+
+ #include ""base/net/downloadmanager.h""
++#include ""base/utils/version.h""
+ #include ""base/version.h""
+
+ namespace
+ {
+ bool isVersionMoreRecent(const QString &remoteVersion)
+ {
+- const QRegularExpressionMatch regVerMatch = QRegularExpression(""([0-9.]+)"").match(QBT_VERSION);
+- if (regVerMatch.hasMatch())
+- {
+- const QString localVersion = regVerMatch.captured(1);
+- const QVector