chentianya/filex
1
0
Fork 0
mirror of https://github.com/eclipse-threadx/filex.git synced 2026-09-14 04:05:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
30e1d491a92c03cf8f52d1ef28fd017eb9bfb268
filex/test/regression_test/filex_utility_test.c
T
Frédéric DesbiensandCopilot 30e1d491a9 Added copyright headers to files missing them 
Applied the standard MIT license header to all project-owned C, header,
assembly, shell, and Python files that were missing a copyright notice.
Third-party, toolchain startup, and auto-generated files were excluded.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-06-06 21:48:17 +02:00

833 lines
30 KiB
C
Raw Blame History

/***************************************************************************/
/* Copyright (c) 2024 Microsoft Corporation */
/* Copyright (c) 2026 Eclipse ThreadX contributors */
/* */
/* This program and the accompanying materials are made available under */
/* the terms of the MIT License which is available at */
/* https://opensource.org/licenses/MIT. */
/* */
/* SPDX-License-Identifier: MIT */
/***************************************************************************/
/* This FileX test concentrates on the utility APIs. */
#include "fx_api.h"
#include "fx_ram_driver_test.h"
#include "fx_utility.h"
#include <stdio.h>
void filex_utility_application_define(void *first_unused_memory);
void test_control_return(UINT status);
#define DEMO_STACK_SIZE 8192
#define CACHE_SIZE 16*128
/* Define the ThreadX and FileX object control blocks... */
#ifndef FX_STANDALONE_ENABLE
static TX_THREAD ftest_0;
#endif
static FX_MEDIA ram_disk;
/* Define the counters used in the test application... */
#ifndef FX_STANDALONE_ENABLE
static UCHAR *ram_disk_memory;
static UCHAR *cache_buffer;
#else
static UCHAR cache_buffer[CACHE_SIZE];
#endif
extern UCHAR _fx_media_format_oem_name[8];
extern UCHAR _fx_media_format_media_type;
extern ULONG _fx_media_format_volume_id;
static UCHAR partition_sector[] = {
0xfa, 0xb8, 0x00, 0x00, 0x8e, 0xd0, 0xbc, 0x00, 0x7c, 0x8b, 0xf4, 0x50, 0x07, 0x50, 0x1f, 0xfb,
0xfc, 0xbf, 0x00, 0x06, 0xb9, 0x00, 0x01, 0xf3, 0xa5, 0xea, 0x1e, 0x06, 0x00, 0x00, 0xbe, 0xbe,
0x07, 0x80, 0x3c, 0x80, 0x74, 0x02, 0xcd, 0x18, 0x56, 0x53, 0x06, 0xbb, 0x00, 0x7c, 0xb9, 0x01,
0x00, 0xba, 0x00, 0x00, 0xb8, 0x01, 0x02, 0xcd, 0x13, 0x07, 0x5b, 0x5e, 0xb2, 0x80, 0x72, 0x0b,
0xbf, 0xbc, 0x7d, 0x81, 0x3d, 0x55, 0x53, 0x75, 0x02, 0xb2, 0x00, 0xbf, 0xeb, 0x06, 0x88, 0x15,
0x8a, 0x74, 0x01, 0x8b, 0x4c, 0x02, 0x8b, 0xee, 0xeb, 0x15, 0xbe, 0x9b, 0x06, 0xac, 0x3c, 0x00,
0x74, 0x0b, 0x56, 0xbb, 0x07, 0x00, 0xb4, 0x0e, 0xcd, 0x10, 0x5e, 0xeb, 0xf0, 0xeb, 0xfe, 0xbb,
0x00, 0x7c, 0xb8, 0x01, 0x02, 0xcd, 0x13, 0x73, 0x05, 0xbe, 0xb3, 0x06, 0xeb, 0xdf, 0xbe, 0xd2,
0x06, 0xbf, 0xfe, 0x7d, 0x81, 0x3d, 0x55, 0xaa, 0x75, 0xd3, 0xbf, 0x24, 0x7c, 0xbe, 0xeb, 0x06,
0x8a, 0x04, 0x88, 0x05, 0x8b, 0xf5, 0xea, 0x00, 0x7c, 0x00, 0x00, 0x49, 0x6e, 0x76, 0x61, 0x6c,
0x69, 0x64, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x00, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67,
0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65,
0x6d, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x1a, 0xb8, 0x5e, 0x00, 0x00, 0x00, 0x14,
0x35, 0x00, 0x0c, 0xfe, 0xff, 0xe9, 0x20, 0x05, 0x00, 0x00, 0xe0, 0xa2, 0xf5, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
};
#define TEST_COUNT 5
/* Define thread prototypes. */
static void ftest_0_entry(ULONG thread_input);
VOID _fx_ram_driver(FX_MEDIA *media_ptr);
UINT fx_media_format_oem_name_set(UCHAR new_oem_name[8]);
UINT fx_media_format_type_set(UCHAR new_media_type);
UINT fx_media_format_volume_id_set(ULONG new_volume_id);
UINT _fx_partition_offset_calculate(void *partition_sector, UINT partition,
ULONG *partition_start, ULONG *partition_size);
/* Define what the initial system looks like. */
#ifdef CTEST
void test_application_define(void *first_unused_memory)
#else
void filex_utility_application_define(void *first_unused_memory)
#endif
{
#ifndef FX_STANDALONE_ENABLE
UCHAR *pointer;
/* Setup the working pointer. */
pointer = (UCHAR *) first_unused_memory;
/* Create the main thread. */
tx_thread_create(&ftest_0, "thread 0", ftest_0_entry, 0,
pointer, DEMO_STACK_SIZE,
4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
pointer = pointer + DEMO_STACK_SIZE;
/* Setup memory for the RAM disk and the sector cache. */
cache_buffer = pointer;
pointer = pointer + CACHE_SIZE;
ram_disk_memory = pointer;
#endif
/* Initialize the FileX system. */
fx_system_initialize();
#ifdef FX_STANDALONE_ENABLE
ftest_0_entry(0);
#endif
}
static void no_partition_test()
{
UINT i;
UINT status;
ULONG total_sectors;
ULONG partition_start;
ULONG partition_size;
/* Loop to test FAT 12, 16, 32. */
for (i = 0; i < TEST_COUNT; i ++)
{
if (i == 0)
{
/* Format the media with FAT12. This needs to be done before opening it! */
total_sectors = 256;
status = fx_media_format(&ram_disk,
_fx_ram_driver, // Driver entry
ram_disk_memory_large, // RAM disk memory pointer
cache_buffer, // Media buffer pointer
CACHE_SIZE, // Media buffer size
"MY_RAM_DISK", // Volume Name
1, // Number of FATs
32, // Directory Entries
0, // Hidden sectors
total_sectors, // Total sectors
512, // Sector size
8, // Sectors per cluster
1, // Heads
1); // Sectors per track
}
else if (i == 1)
{
/* Format the media with FAT16. This needs to be done before opening it! */
total_sectors = 4200 * 8;
status = fx_media_format(&ram_disk,
_fx_ram_driver, // Driver entry
ram_disk_memory_large, // RAM disk memory pointer
cache_buffer, // Media buffer pointer
CACHE_SIZE, // Media buffer size
"MY_RAM_DISK", // Volume Name
1, // Number of FATs
32, // Directory Entries
0, // Hidden sectors
total_sectors, // Total sectors
512, // Sector size
8, // Sectors per cluster
1, // Heads
1); // Sectors per track
}
else if (i == 2)
{
/* Format the media with FAT32. This needs to be done before opening it! */
total_sectors = 70000 * 8;
status = fx_media_format(&ram_disk,
_fx_ram_driver, // Driver entry
ram_disk_memory_large, // RAM disk memory pointer
cache_buffer, // Media buffer pointer
CACHE_SIZE, // Media buffer size
"MY_RAM_DISK", // Volume Name
1, // Number of FATs
32, // Directory Entries
0, // Hidden sectors
total_sectors, // Total sectors
512, // Sector size
8, // Sectors per cluster
1, // Heads
1); // Sectors per track
}
else if (i == 3)
{
/* Format the media with FAT12. This needs to be done before opening it! */
total_sectors = 256;
status = fx_media_format(&ram_disk,
_fx_ram_driver, // Driver entry
ram_disk_memory_large, // RAM disk memory pointer
cache_buffer, // Media buffer pointer
CACHE_SIZE, // Media buffer size
"MY_RAM_DISK", // Volume Name
1, // Number of FATs
32, // Directory Entries
0, // Hidden sectors
total_sectors, // Total sectors
128, // Sector size
8, // Sectors per cluster
1, // Heads
1); // Sectors per track
}
else if (i == 4)
{
/* Format the media with FAT12. This needs to be done before opening it! */
total_sectors = 256;
status = fx_media_format(&ram_disk,
_fx_ram_driver, // Driver entry
ram_disk_memory_large, // RAM disk memory pointer
cache_buffer, // Media buffer pointer
CACHE_SIZE, // Media buffer size
"MY_RAM_DISK", // Volume Name
1, // Number of FATs
32, // Directory Entries
0, // Hidden sectors
total_sectors, // Total sectors
1024, // Sector size
8, // Sectors per cluster
1, // Heads
1); // Sectors per track
}
return_if_fail( status == FX_SUCCESS);
/* Get partition offset and size. */
_fx_partition_offset_calculate(ram_disk_memory_large, 0, &partition_start, &partition_size);
/* Check partition offset and size. */
return_value_if_fail(partition_start == 0, 6);
return_value_if_fail(partition_size == total_sectors, 7);
}
}
/* Define the test threads. */
static void ftest_0_entry(ULONG thread_input)
{
UCHAR oem_name[8] = {'O', 'E', 'M', ' ', 'N', 'A', 'M', 'E'};
ULONG partition_start;
ULONG partition_size;
ULONG FAT_sector;
ULONG64 value;
CHAR buffer[16];
UINT size;
UINT status;
UINT partition_sector_value;
FX_MEDIA tmp_media;
ULONG temp;
ULONG temp1;
ULONG temp2;
ULONG temp3;
ULONG temp4;
ULONG temp5;
ULONG temp6;
FX_PARAMETER_NOT_USED(thread_input);
/* Print out some test information banners. */
printf("FileX Test: Utility test...........................................");
/* Modify OEM_NAME. */
fx_media_format_oem_name_set(oem_name);
/* Check OEM_NAME. */
return_value_if_fail(memcmp(oem_name, _fx_media_format_oem_name, sizeof(oem_name)) == 0, 1);
/* Modify media_type. */
fx_media_format_type_set(0xF0);
/* Check media_type. */
return_value_if_fail(_fx_media_format_media_type == 0xF0, 2);
/* Modify volume_id. */
fx_media_format_volume_id_set(0xFF);
/* Check media_type. */
return_value_if_fail(_fx_media_format_volume_id == 0xFF, 3);
/* Get partition offset and size. */
_fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check partition offset and size. */
return_value_if_fail(partition_start == 0x0520, 4);
return_value_if_fail(partition_size == 0xF5A2E0, 5);
/* Check for error in _fx_partition_offset_calculate when buffer is invalid. */
/* Induce error in buffer */
partition_sector[510] = 0xFF;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_NOT_FOUND)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate!\n");
test_control_return(1);
}
/* Restore buffer */
partition_sector[510] = 0x55;
/* BRANCH COVERAGE TESTS START */
/* Induce error in buffer */
partition_sector[511] = 0xFF;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_NOT_FOUND)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate!\n");
test_control_return(2);
}
/* Restore buffer */
partition_sector[511] = 0xAA;
partition_sector_value = partition_sector[0];
/* Induce error in buffer */
partition_sector[0] = 0xFF;
status = _fx_partition_offset_calculate(partition_sector, 100, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_NOT_FOUND)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(3);
}
/* Restore buffer */
partition_sector[0] = partition_sector_value;
partition_sector_value = partition_sector[2];
/* Induce error in buffer */
partition_sector[2] = 0xFF;
status = _fx_partition_offset_calculate(partition_sector, 100, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_NOT_FOUND)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(4);
}
/* Restore buffer */
partition_sector[2] = partition_sector_value;
partition_sector_value = partition_sector[0];
/* Induce error in buffer */
partition_sector[0] = 0xe9;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(5);
}
/* Restore buffer */
partition_sector[0] = partition_sector_value;
partition_sector_value = partition_sector[0];
/* Induce error in buffer */
partition_sector[0] = 0xeb;
status = _fx_partition_offset_calculate(partition_sector, 100, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_NOT_FOUND)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(5);
}
/* Restore buffer */
partition_sector[0] = partition_sector_value;
partition_sector_value = partition_sector[0];
temp = partition_sector[2];
/* Induce error in buffer */
partition_sector[0] = 0xeb;
partition_sector[2] = 0x90;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(6);
}
/* Restore buffer */
partition_sector[0] = partition_sector_value;
partition_sector[2] = temp;
partition_sector_value = partition_sector[0];
temp = partition_sector[2];
/* Induce error in buffer */
partition_sector[0] = 0xe9;
partition_sector[2] = 0x90;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(6);
}
/* Restore buffer */
partition_sector[0] = partition_sector_value;
partition_sector[2] = temp;
/* Test to check the partition_sector values, if there are good values for sectors per FAT.
We want the test code to return FX_NOT_FOUND after _fx_utility_partition_get() is called */
/* Set real boot sector check to true */
temp6 = partition_sector[0];
partition_sector[0] = 0xe9;
temp = partition_sector[0x16];
temp1 = partition_sector[0x17];
temp2 = partition_sector[0x24];
temp3 = partition_sector[0x25];
temp4 = partition_sector[0x26];
temp5 = partition_sector[0x27];
/* Induce error in buffer */
partition_sector[0x16] = 0;
partition_sector[0x17] = 0;
partition_sector[0x24] = 0;
partition_sector[0x25] = 0;
partition_sector[0x26] = 0;
partition_sector[0x27] = 0;
status = _fx_partition_offset_calculate(partition_sector, 100, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_NOT_FOUND)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(7);
}
/* Restore buffer */
partition_sector[0x16] = temp;
partition_sector[0x17] = temp1;
partition_sector[0x24] = temp2;
partition_sector[0x25] = temp3;
partition_sector[0x26] = temp4;
partition_sector[0x27] = temp5;
/* Induce error in buffer */
partition_sector[0x17] = 0;
partition_sector[0x24] = 0;
partition_sector[0x25] = 0;
partition_sector[0x26] = 0;
partition_sector[0x27] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(8);
}
/* Restore buffer */
partition_sector[0x17] = temp1;
partition_sector[0x24] = temp2;
partition_sector[0x25] = temp3;
partition_sector[0x26] = temp4;
partition_sector[0x27] = temp5;
/* Induce error in buffer */
partition_sector[0x16] = 0;
partition_sector[0x24] = 0;
partition_sector[0x25] = 0;
partition_sector[0x26] = 0;
partition_sector[0x27] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(9);
}
/* Restore buffer */
partition_sector[0x16] = temp;
partition_sector[0x24] = temp2;
partition_sector[0x25] = temp3;
partition_sector[0x26] = temp4;
partition_sector[0x27] = temp5;
/* Induce error in buffer */
partition_sector[0x16] = 0;
partition_sector[0x17] = 0;
partition_sector[0x25] = 0;
partition_sector[0x26] = 0;
partition_sector[0x27] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(10);
}
/* Restore buffer */
partition_sector[0x16] = temp;
partition_sector[0x17] = temp1;
partition_sector[0x25] = temp3;
partition_sector[0x26] = temp4;
partition_sector[0x27] = temp5;
/* Induce error in buffer */
partition_sector[0x16] = 0;
partition_sector[0x17] = 0;
partition_sector[0x24] = 0;
partition_sector[0x26] = 0;
partition_sector[0x27] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(11);
}
/* Restore buffer */
partition_sector[0x16] = temp;
partition_sector[0x17] = temp1;
partition_sector[0x24] = temp2;
partition_sector[0x26] = temp4;
partition_sector[0x27] = temp5;
/* Induce error in buffer */
partition_sector[0x16] = 0;
partition_sector[0x17] = 0;
partition_sector[0x24] = 0;
partition_sector[0x25] = 0;
partition_sector[0x27] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(12);
}
/* Restore buffer */
partition_sector[0x16] = temp;
partition_sector[0x17] = temp1;
partition_sector[0x24] = temp2;
partition_sector[0x25] = temp3;
partition_sector[0x27] = temp5;
/* Induce error in buffer */
partition_sector[0x16] = 0;
partition_sector[0x17] = 0;
partition_sector[0x24] = 0;
partition_sector[0x25] = 0;
partition_sector[0x26] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(13);
}
/* Restore buffer */
partition_sector[0x16] = temp;
partition_sector[0x17] = temp1;
partition_sector[0x24] = temp2;
partition_sector[0x25] = temp3;
partition_sector[0x26] = temp4;
temp = partition_sector[0x20];
temp1 = partition_sector[0x21];
temp2 = partition_sector[0x22];
temp3 = partition_sector[0x23];
/* Set calculatation of the total sectors based of FAT32 */
temp4 = partition_sector[0x13];
temp5 = partition_sector[0x14];
partition_sector[0x13] = 0;
partition_sector[0x14] = 0;
/* Induce error in buffer */
partition_sector[0x20] = 0;
partition_sector[0x21] = 0;
partition_sector[0x22] = 0;
partition_sector[0x23] = 0;
status = _fx_partition_offset_calculate(partition_sector, 100, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_NOT_FOUND)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(14);
}
/* Restore buffer */
partition_sector[0x20] = temp;
partition_sector[0x21] = temp1;
partition_sector[0x22] = temp2;
partition_sector[0x23] = temp3;
/* Induce error in buffer */
partition_sector[0x21] = 0;
partition_sector[0x22] = 0;
partition_sector[0x23] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(15);
}
/* Restore buffer */
partition_sector[0x21] = temp1;
partition_sector[0x22] = temp2;
partition_sector[0x23] = temp3;
/* Induce error in buffer */
partition_sector[0x20] = 0;
partition_sector[0x22] = 0;
partition_sector[0x23] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(16);
}
/* Restore buffer */
partition_sector[0x20] = temp;
partition_sector[0x22] = temp2;
partition_sector[0x23] = temp3;
/* Induce error in buffer */
partition_sector[0x20] = 0;
partition_sector[0x21] = 0;
partition_sector[0x23] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(17);
}
/* Restore buffer */
partition_sector[0x20] = temp;
partition_sector[0x21] = temp1;
partition_sector[0x23] = temp3;
/* Induce error in buffer */
partition_sector[0x20] = 0;
partition_sector[0x21] = 0;
partition_sector[0x22] = 0;
status = _fx_partition_offset_calculate(partition_sector, 0, &partition_start, &partition_size);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(18);
}
/* Check for partition_start and partition_size to be NULL */
status = _fx_partition_offset_calculate(partition_sector, 0, FX_NULL, FX_NULL);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(19);
}
/* Restore buffer */
partition_sector[0x20] = temp;
partition_sector[0x21] = temp1;
partition_sector[0x22] = temp2;
/* Restore real boot sector and the total sector check to default */
partition_sector[0] = temp6;
partition_sector[0x13] = temp4;
partition_sector[0x14] = temp5;
/* Check for partition_start and partition_size to be NULL to cover line 236 and 242 */
status = _fx_partition_offset_calculate(partition_sector, 0, FX_NULL, FX_NULL);
/* Check for the error. */
if (status != FX_SUCCESS)
{
/* Print error message. */
printf("Error in checking of _fx_partition_offset_calculate! %d\n",status);
test_control_return(20);
}
/* BRANCH COVERAGE TESTS END */
/* Invoke _fx_utility_memory_set and _fx_utility_string_length_get. */
_fx_utility_memory_set((UCHAR*)buffer, 0, 0);
_fx_utility_memory_set((UCHAR*)buffer, 0, sizeof(buffer));
size = _fx_utility_string_length_get(buffer, sizeof(buffer));
return_if_fail(size == 0);
buffer[0] = 'a';
size = _fx_utility_string_length_get(buffer, sizeof(buffer));
return_if_fail(size == 1);
_fx_utility_memory_set((UCHAR*)buffer, 'a', sizeof(buffer));
size = _fx_utility_string_length_get(buffer, sizeof(buffer));
return_if_fail(size == sizeof(buffer));
_fx_utility_memory_set((UCHAR*)buffer, 'a', sizeof(buffer));
size = _fx_utility_string_length_get(buffer, 1);
return_if_fail(size == 1);
/* Tests for utility_64_unsigned_read, utility_64_unsigned_write and utility_FAT_sector_get. */
_fx_utility_64_unsigned_write((UCHAR*)buffer, 0x0001);
value = _fx_utility_64_unsigned_read((UCHAR*)buffer);
return_if_fail(0x0001 == value);
/* Tests for utility_FAT_sector_get. */
tmp_media.fx_media_bytes_per_sector = 512;
tmp_media.fx_media_reserved_sectors = 0;
/* 12-bit FAT. */
tmp_media.fx_media_12_bit_FAT = 1;
/* The FAT entry of cluster 400 is located at the second sector. */
FAT_sector = _fx_utility_FAT_sector_get(&tmp_media, 400);
return_if_fail(1 == FAT_sector);
/* 16-bit FAT. */
tmp_media.fx_media_12_bit_FAT = 0;
tmp_media.fx_media_32_bit_FAT = 0;
/* The FAT entry of cluster 400 is located at the second sector. */
FAT_sector = _fx_utility_FAT_sector_get(&tmp_media, 400);
return_if_fail(1 == FAT_sector);
/* 32-bit FAT. */
tmp_media.fx_media_12_bit_FAT = 0;
tmp_media.fx_media_32_bit_FAT = 1;
/* The FAT entry of cluster 400 is located at the fourth sector. */
FAT_sector = _fx_utility_FAT_sector_get(&tmp_media, 400);
return_if_fail(3 == FAT_sector);
no_partition_test();
printf("SUCCESS!\n");
test_control_return(0);
}
Reference in New Issue View Git Blame Copy Permalink