/* Tests the libcdirectory_directory_entry_free function
* Returns 1 if successful or 0 if not
*/
int cdirectory_test_directory_entry_free(
void )
{
libcerror_error_t *error = NULL;
int result = 0;
/* Test error cases
*/
result = libcdirectory_directory_entry_free(
NULL,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
return( 0 );
}
/* Retrieves the name of a directory entry by name ignoring case
* If a corresponding entry is found entry name is update
* This function is needed to find case insensitive directory entries on a case sensitive system
* Return 1 if successful, 0 if no corresponding entry was found or -1 on error
*/
int path_handle_get_directory_entry_name_by_name_no_case(
path_handle_t *path_handle,
const libcstring_system_character_t *path,
size_t path_length,
libcstring_system_character_t *entry_name,
size_t entry_name_size,
uint8_t entry_type,
libcerror_error_t **error )
{
libcdirectory_directory_t *directory = NULL;
libcdirectory_directory_entry_t *directory_entry = NULL;
libcstring_system_character_t *directory_entry_name = NULL;
static char *function = "path_handle_get_directory_entry_name_by_name_no_case";
size_t directory_entry_name_length = 0;
int result = 0;
if( path_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid path handle.",
function );
return( -1 );
}
if( path_length > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid path length value exceeds maximum.",
function );
return( -1 );
}
if( entry_name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry name.",
function );
return( -1 );
}
if( entry_name_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid entry name size value exceeds maximum.",
function );
return( -1 );
}
if( entry_name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry name.",
function );
return( -1 );
}
if( libcdirectory_directory_initialize(
&directory,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create directory.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libcdirectory_directory_open_wide(
directory,
path,
error );
#else
result = libcdirectory_directory_open(
directory,
path,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open directory: %" PRIs_LIBCSTRING_SYSTEM ".",
function,
path );
goto on_error;
}
if( libcdirectory_directory_entry_initialize(
&directory_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create directory entry.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libcdirectory_directory_has_entry_wide(
directory,
directory_entry,
entry_name,
entry_name_size - 1,
entry_type,
LIBCDIRECTORY_COMPARE_FLAG_NO_CASE,
error );
#else
result = libcdirectory_directory_has_entry(
directory,
directory_entry,
entry_name,
entry_name_size - 1,
entry_type,
LIBCDIRECTORY_COMPARE_FLAG_NO_CASE,
error );
#endif
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
"%s: unable to determine if directory has entry: %" PRIs_LIBCSTRING_SYSTEM ".",
function,
entry_name );
goto on_error;
}
else if( result != 0 )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libcdirectory_directory_entry_get_name_wide(
directory_entry,
(wchar_t **) &directory_entry_name,
error );
#else
result = libcdirectory_directory_entry_get_name(
directory_entry,
(char **) &directory_entry_name,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve directory entry name.",
function );
goto on_error;
}
directory_entry_name_length = libcstring_system_string_length(
directory_entry_name );
if( ( directory_entry_name_length + 1 ) != entry_name_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: entry name length value out of bounds.",
function );
goto on_error;
}
if( libcstring_system_string_copy(
entry_name,
directory_entry_name,
directory_entry_name_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set entry name.",
function );
goto on_error;
}
}
if( libcdirectory_directory_entry_free(
&directory_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free directory entry.",
function );
goto on_error;
}
if( libcdirectory_directory_close(
directory,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close directory.",
function );
goto on_error;
}
if( libcdirectory_directory_free(
&directory,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free directory.",
function );
goto on_error;
}
return( result );
on_error:
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
if( directory != NULL )
{
libcdirectory_directory_free(
&directory,
NULL );
}
return( -1 );
}
/* Tests the libcdirectory_directory_entry_get_name_wide function
* Returns 1 if successful or 0 if not
*/
int cdirectory_test_directory_entry_get_name_wide(
void )
{
libcdirectory_directory_t *directory = NULL;
libcdirectory_directory_entry_t *directory_entry = NULL;
libcerror_error_t *error = NULL;
wchar_t *entry_name = NULL;
int result = 0;
/* Initialize test
*/
result = libcdirectory_directory_initialize(
&directory,
&error );
result = libcdirectory_directory_open(
directory,
".",
&error );
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
result = libcdirectory_directory_has_entry_wide(
directory,
directory_entry,
L"Makefile.am",
11,
LIBCDIRECTORY_ENTRY_TYPE_FILE,
0,
&error );
/* Test retrieving the name of a directory entry
*/
result = libcdirectory_directory_entry_get_name_wide(
directory_entry,
&entry_name,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
result = wide_string_compare(
entry_name,
L"Makefile.am",
11 );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
/* Test error cases
*/
result = libcdirectory_directory_entry_get_name_wide(
NULL,
&entry_name,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libcdirectory_directory_entry_get_name_wide(
directory_entry,
NULL,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up
*/
result = libcdirectory_directory_entry_free(
&directory_entry,
NULL );
result = libcdirectory_directory_free(
&directory,
NULL );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
if( directory != NULL )
{
libcdirectory_directory_free(
&directory,
NULL );
}
return( 0 );
}
/* Tests the libcdirectory_directory_entry_initialize function
* Returns 1 if successful or 0 if not
*/
int cdirectory_test_directory_entry_initialize(
void )
{
libcdirectory_directory_entry_t *directory_entry = NULL;
libcerror_error_t *error = NULL;
int result = 0;
#if defined( HAVE_CDIRECTORY_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 = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
result = libcdirectory_directory_entry_free(
&directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libcdirectory_directory_entry_initialize(
NULL,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
directory_entry = (libcdirectory_directory_entry_t *) 0x12345678UL;
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
directory_entry = NULL;
#if defined( HAVE_CDIRECTORY_TEST_MEMORY )
for( test_number = 0;
test_number < number_of_malloc_fail_tests;
test_number++ )
{
/* Test libcdirectory_directory_entry_initialize with malloc failing
*/
cdirectory_test_malloc_attempts_before_fail = test_number;
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
if( cdirectory_test_malloc_attempts_before_fail != -1 )
{
cdirectory_test_malloc_attempts_before_fail = -1;
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
}
else
{
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_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 libcdirectory_directory_entry_initialize with memset failing
*/
cdirectory_test_memset_attempts_before_fail = test_number;
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
if( cdirectory_test_memset_attempts_before_fail != -1 )
{
cdirectory_test_memset_attempts_before_fail = -1;
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
}
else
{
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
}
#endif /* defined( HAVE_CDIRECTORY_TEST_MEMORY ) */
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
return( 0 );
}
/* Tests the libcdirectory_directory_entry_copy function
* Returns 1 if successful or 0 if not
*/
int cdirectory_test_directory_entry_copy(
void )
{
libcdirectory_directory_entry_t *destination_directory_entry = NULL;
libcdirectory_directory_entry_t *directory_entry = NULL;
libcerror_error_t *error = NULL;
int result = 0;
/* Initialize test
*/
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
result = libcdirectory_directory_entry_initialize(
&destination_directory_entry,
&error );
/* Test directory entry copy
*/
result = libcdirectory_directory_entry_copy(
destination_directory_entry,
directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libcdirectory_directory_entry_copy(
NULL,
directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libcdirectory_directory_entry_copy(
destination_directory_entry,
NULL,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
#if defined( HAVE_CDIRECTORY_TEST_MEMORY )
/* Test libcdirectory_directory_entry_initialize with memcpy failing
*/
cdirectory_test_memcpy_attempts_before_fail = 0;
result = libcdirectory_directory_entry_copy(
destination_directory_entry,
directory_entry,
&error );
if( cdirectory_test_memcpy_attempts_before_fail != -1 )
{
cdirectory_test_memcpy_attempts_before_fail = -1;
}
else
{
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
#endif /* defined( HAVE_CDIRECTORY_TEST_MEMORY ) */
/* Clean up
*/
result = libcdirectory_directory_entry_free(
&destination_directory_entry,
NULL );
result = libcdirectory_directory_entry_free(
&directory_entry,
NULL );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( destination_directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&destination_directory_entry,
NULL );
}
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
return( 0 );
}
