+#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