ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

FILESYSTEM: fopen() and basic test improvements.

pull/3762/head
Simon Hughes 2016-12-23 16:58:25 +00:00
parent b1a685125b
commit 912044b829
5 changed files with 386 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
features/TESTS/filesystem/basic/basic.cpp
View File

@ -48,12 +48,17 @@
#include "mbed.h"
#include "SDFileSystem.h"
#include "test_env.h"
#include "fsfat_debug.h"
#include "fsfat_test.h"
#include "utest/utest.h"
#include "unity/unity.h"
#include "greentea-client/test_env.h"
#include <stdio.h>
/* FIXME: unistd.h needed for fsfat_basic_test_04 but this error is generated:
* [Error] unistd.h@185,10: conflicting declaration of C function 'unsigned int sleep(unsigned int)'
* #include <unistd.h> // STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO
*/
#include <stdlib.h>
#include <string.h>
@ -66,6 +71,9 @@ using namespace utest::v1;
* If the target has an SD card installed then uncomment the #define FSFAT_SDCARD_INSTALLED directive for the target.
*/
/* #define FSFAT_SDCARD_INSTALLED */
//todo: remove next 2 lines.
#define FSFAT_SDCARD_INSTALLED
#define DEVICE_SPI
#if defined(DEVICE_SPI) && defined(FSFAT_SDCARD_INSTALLED)
#if defined(TARGET_KL25Z)
@ -129,6 +137,8 @@ SDFileSystem sd(SDMOSI, SDMISO, SDSCLK, SDSSEL, "sd");
#define FSFAT_BASIC_TEST_00 fsfat_basic_test_00
#define FSFAT_BASIC_TEST_01 fsfat_basic_test_01
#define FSFAT_BASIC_TEST_02 fsfat_basic_test_02
#define FSFAT_BASIC_TEST_03 fsfat_basic_test_03
#define FSFAT_BASIC_TEST_04 fsfat_basic_test_04
#define FSFAT_BASIC_MSG_BUF_SIZE 256
@ -155,13 +165,16 @@ static char fsfat_basic_msg_g[FSFAT_BASIC_MSG_BUF_SIZE];
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
static control_t fsfat_basic_test_00() {
static control_t fsfat_basic_test_00()
{
uint8_t data_written[FSFAT_BASIC_DATA_SIZE] = { 0 };
bool result = false;
bool read_result = false;
// Fill data_written buffer with random data
// Write these data into the file
FSFAT_FENTRYLOG("%s:entered\n", __func__);
bool write_result = false;
{
printf("SD: Writing ... ");
@ -178,7 +191,6 @@ static control_t fsfat_basic_test_00() {
}
// Read back the data from the file and store them in data_read
bool read_result = false;
{
printf("SD: Reading data ... ");
FILE *f = fopen(sd_file_path, "r");
@ -206,11 +218,13 @@ extern int errno;
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
static control_t fsfat_basic_test_01() {
static control_t fsfat_basic_test_01()
{
FILE *fp, *fp1;
int i, j;
int ret = 0;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
fp = fopen (sd_file_path, "w+");
if (fp == NULL) {
printf("errno=%d\n", errno);
@ -269,7 +283,8 @@ static control_t fsfat_basic_test_01() {
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
static control_t fsfat_basic_test_02() {
static control_t fsfat_basic_test_02()
{
static const char hello[] = "Hello, world.\n";
static const char replace[] = "Hewwo, world.\n";
static const size_t replace_from = 2, replace_to = 4;
@ -280,6 +295,7 @@ static control_t fsfat_basic_test_02() {
int32_t ret = 0;
char *rets = NULL;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
f = fopen(filename, "w+");
if (f == NULL) {
FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Cannot open file for writing (filename=%s).\n", __func__, filename);
@ -384,12 +400,92 @@ static control_t fsfat_basic_test_02() {
return CaseNext;
}
/** @brief temptest.c test ported from glibc project. See the licence at REF_LICENCE_GLIBC.
*
* WARNING: this test does not currently work. See WARNING comments below.
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
static control_t fsfat_basic_test_03()
{
char *fn;
FILE *fp;
char *files[500];
int i;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
memset(files, 0, 500*sizeof(char*));
for (i = 0; i < 500; i++) {
fn = tmpnam((char *) NULL);
/* FIXME: tmpnam() doesnt currently generate a temporary filename
* re-instate the code below when it does.
FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to generate a temporary filename.\n", __func__);
TEST_ASSERT_MESSAGE(fn != NULL, fsfat_basic_msg_g);
files[i] = strdup(fn);
FSFAT_DBGLOG("%s:filename=%s\n", __func__, fn);
fp = fopen (fn, "w");
fclose(fp);
*/
}
for (i = 0; i < 500; i++) {
if(files[i] != NULL) {
remove(files[i]);
free(files[i]);
}
}
return CaseNext;
}
static bool fsfat_basic_fileno_check(const char *name, FILE *stream, int fd)
{
int sfd = fileno (stream);
FSFAT_DBGLOG("(fileno (%s) = %d) %c= %d\n", name, sfd, sfd == fd ? '=' : '!', fd);
if (sfd == fd) {
return true;
} else {
return false;
}
}
/** @brief tst-fileno.c test ported from glibc project. See the licence at REF_LICENCE_GLIBC.
*
* WARNING: this test does not currently work. See WARNING comments below.
*
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
static control_t fsfat_basic_test_04()
{
/* FIXME: unistd.h needed for STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO but this error is generated:
* [Error] unistd.h@185,10: conflicting declaration of C function 'unsigned int sleep(unsigned int)'
int ret = -1;
ret = fsfat_basic_fileno_check("stdin", stdin, STDIN_FILENO);
FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: stdin does not have expected file number (expected=%d, fileno=%d.\n", __func__, stdin, fileno(stdin));
TEST_ASSERT_MESSAGE(ret == true, fsfat_basic_msg_g);
ret = fsfat_basic_fileno_check("stdout", stdout, STDOUT_FILENO);
FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: stdout does not have expected file number (expected=%d, fileno=%d.\n", __func__, stdout, fileno(stdout));
TEST_ASSERT_MESSAGE(ret == true, fsfat_basic_msg_g);
ret = fsfat_basic_fileno_check("stderr", stderr, STDERR_FILENO);
FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: stderr does not have expected file number (expected=%d, fileno=%d.\n", __func__, stderr, fileno(stderr));
TEST_ASSERT_MESSAGE(ret == true, fsfat_basic_msg_g);
*/
return CaseNext;
}
#else
#define FSFAT_BASIC_TEST_00 fsfat_basic_test_dummy
#define FSFAT_BASIC_TEST_01 fsfat_basic_test_dummy
#define FSFAT_BASIC_TEST_02 fsfat_basic_test_dummy
#define FSFAT_BASIC_TEST_03 fsfat_basic_test_dummy
#define FSFAT_BASIC_TEST_04 fsfat_basic_test_dummy
/** @brief fsfat_basic_test_dummy Dummy test case for testing when platform doesnt have an SDCard installed.
*
@ -413,10 +509,13 @@ utest::v1::status_t greentea_setup(const size_t number_of_cases)
Case cases[] = {
/* 1 2 3 4 5 6 7 */
/* 1234567890123456789012345678901234567890123456789012345678901234567890 */
Case("FSFAT_test_00: fopen()/fgetc()/fprintf()/fclose() test.", FSFAT_BASIC_TEST_00),
Case("FSFAT_test_01: fopen()/fseek()/fclose() test.", FSFAT_BASIC_TEST_01)
Case("FSFAT_BASIC_TEST_00: fopen()/fgetc()/fprintf()/fclose() test.", FSFAT_BASIC_TEST_00),
Case("FSFAT_BASIC_TEST_01: fopen()/fseek()/fclose() test.", FSFAT_BASIC_TEST_01)
/* WARNING: Test case not working but currently not required for PAL support
* Case("FSFAT_test_02: fopen()/fgets()/fputs()/ftell()/rewind()/remove() test.", FSFAT_BASIC_TEST_02) */
* Case("FSFAT_BASIC_TEST_02: fopen()/fgets()/fputs()/ftell()/rewind()/remove() test.", FSFAT_BASIC_TEST_02)
* Case("FSFAT_BASIC_TEST_03: tmpnam() test.", FSFAT_BASIC_TEST_03)
* Case("FSFAT_BASIC_TEST_04: fileno() test.", FSFAT_BASIC_TEST_04)
*/
};

470
features/TESTS/filesystem/fopen/fopen.cpp
View File

@ -15,7 +15,7 @@
* limitations under the License.
*/
/** @file open.cpp Test cases to open KVs in the FSFAT using the drv->Open() interface.
/** @file fopen.cpp Test cases to POSIX file fopen() interface.
*
* Please consult the documentation under the test-case functions for
* a description of the individual test case.
@ -53,6 +53,9 @@ using namespace utest::v1;
* If the target has an SD card installed then uncomment the #define FSFAT_SDCARD_INSTALLED directive for the target.
*/
/* #define FSFAT_SDCARD_INSTALLED */
//todo: remove next 2 lines.
#define FSFAT_SDCARD_INSTALLED
#define DEVICE_SPI
#if defined(DEVICE_SPI) && defined(FSFAT_SDCARD_INSTALLED)
static char fsfat_fopen_utest_msg_g[FSFAT_UTEST_MSG_BUF_SIZE];
@ -122,17 +125,16 @@ SDFileSystem sd(SDMOSI, SDMISO, SDSCLK, SDSSEL, "sd");
#define FSFAT_FOPEN_TEST_04 fsfat_fopen_test_04
#define FSFAT_FOPEN_TEST_05 fsfat_fopen_test_05
#define FSFAT_FOPEN_TEST_06 fsfat_fopen_test_06
#define FSFAT_FOPEN_TEST_07 fsfat_fopen_test_07
/* support functions */
/*
* open tests that focus on testing fsfat_open()
* fsfat_handle_t fsfat_open(const char* key_name, char* data, ARM_FSFAT_SIZE* len, fsfat_key_desc_t* kdesc)
* open tests that focus on testing fopen()
* fsfat_handle_t fopen(const char* filename, char* data, size_t* len, fsfat_key_desc_t* kdesc)
*/
/* KV data for test_01 */
/* file data for test_01 */
static fsfat_kv_data_t fsfat_fopen_test_01_kv_data[] = {
{ "/sd/fopentst/hello/world/animal/wobbly/dog/foot/frontlft.txt", "missing"},
{ NULL, NULL},
@ -197,7 +199,7 @@ int32_t fsfat_filepath_remove_all(char* filepath)
char *fpathbuf = NULL;
char *pos = NULL;
FSFAT_DBGLOG("%s:entered\n", __func__);
FSFAT_FENTRYLOG("%s:entered\n", __func__);
fpathbuf = strdup(filepath);
if (fpathbuf == NULL) {
FSFAT_DBGLOG("%s: failed to duplicate string (out of memory)\n", __func__);
@ -293,33 +295,33 @@ static control_t fsfat_fopen_test_01(const size_t call_count)
node = fsfat_fopen_test_01_kv_data;
/* remove file and directory from a previous failed test run, if present */
fsfat_filepath_remove_all((char*) node->key_name);
fsfat_filepath_remove_all((char*) node->filename);
/* create dirs*/
ret = fsfat_filepath_make_dirs((char*) node->key_name);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create dirs for filename (filename=\"%s\")(ret=%d)\n", __func__, node->key_name, (int) ret);
ret = fsfat_filepath_make_dirs((char*) node->filename);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create dirs for filename (filename=\"%s\")(ret=%d)\n", __func__, node->filename, (int) ret);
TEST_ASSERT_MESSAGE(ret == 0, fsfat_fopen_utest_msg_g);
FSFAT_DBGLOG("%s:About to create new file (filename=\"%s\", data=\"%s\")\n", __func__, node->key_name, node->value);
fp = fopen(node->key_name, "w+");
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create file (filename=\"%s\", data=\"%s\")(ret=%d, errno=%d)\n", __func__, node->key_name, node->value, (int) ret, errno);
FSFAT_DBGLOG("%s:About to create new file (filename=\"%s\", data=\"%s\")\n", __func__, node->filename, node->value);
fp = fopen(node->filename, "w+");
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create file (filename=\"%s\", data=\"%s\")(ret=%d, errno=%d)\n", __func__, node->filename, node->value, (int) ret, errno);
TEST_ASSERT_MESSAGE(fp != NULL, fsfat_fopen_utest_msg_g);
FSFAT_DBGLOG("%s:length of KV=%d (filename=\"%s\", data=\"%s\")\n", __func__, (int) len, node->key_name, node->value);
FSFAT_DBGLOG("%s:length of file=%d (filename=\"%s\", data=\"%s\")\n", __func__, (int) len, node->filename, node->value);
len = strlen(node->value);
ret = fwrite((const void*) node->value, len, 1, fp);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to write file (filename=\"%s\", data=\"%s\")(ret=%d)\n", __func__, node->key_name, node->value, (int) ret);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to write file (filename=\"%s\", data=\"%s\")(ret=%d)\n", __func__, node->filename, node->value, (int) ret);
TEST_ASSERT_MESSAGE(ret == 1, fsfat_fopen_utest_msg_g);
FSFAT_DBGLOG("Created file successfully (filename=\"%s\", data=\"%s\")\n", node->key_name, node->value);
FSFAT_DBGLOG("Created file successfully (filename=\"%s\", data=\"%s\")\n", node->filename, node->value);
ret = fclose(fp);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to close file (ret=%d, errno=%d)\n", __func__, (int) ret, errno);
TEST_ASSERT_MESSAGE(ret == 0, fsfat_fopen_utest_msg_g);
/* now open the newly created key */
fp = NULL;
fp = fopen(node->key_name, "r");
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open file for reading (filename=\"%s\", data=\"%s\")(ret=%d)\n", __func__, node->key_name, node->value, (int) ret);
fp = fopen(node->filename, "r");
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open file for reading (filename=\"%s\", data=\"%s\")(ret=%d)\n", __func__, node->filename, node->value, (int) ret);
TEST_ASSERT_MESSAGE(fp != NULL, fsfat_fopen_utest_msg_g);
len = strlen(node->value) + 1;
@ -327,10 +329,10 @@ static control_t fsfat_fopen_test_01(const size_t call_count)
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to allocated read buffer \n", __func__);
TEST_ASSERT_MESSAGE(read_buf != NULL, fsfat_fopen_utest_msg_g);
FSFAT_DBGLOG("Opened KV successfully (filename=\"%s\", data=\"%s\")\n", node->key_name, node->value);
FSFAT_DBGLOG("Opened file successfully (filename=\"%s\", data=\"%s\")\n", node->filename, node->value);
memset(read_buf, 0, len);
ret = fread((void*) read_buf, len, 1, fp);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to read file (filename=\"%s\", data=\"%s\", read_buf=\"%s\", ret=%d)\n", __func__, node->key_name, node->value, read_buf, (int) ret);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to read file (filename=\"%s\", data=\"%s\", read_buf=\"%s\", ret=%d)\n", __func__, node->filename, node->value, read_buf, (int) ret);
/* FIX ME: fread should return the number of items read, not 0 when an item is read successfully.
* This indicates a problem with the implementation, as the correct data is read. The correct assert should be:
* TEST_ASSERT_MESSAGE(ret == 1, fsfat_fopen_utest_msg_g);
@ -339,191 +341,166 @@ static control_t fsfat_fopen_test_01(const size_t call_count)
TEST_ASSERT_MESSAGE(ret == 0, fsfat_fopen_utest_msg_g);
/* check read data is as expected */
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: read value data (%s) != expected value data (filename=\"%s\", data=\"%s\", read_buf=\"%s\", ret=%d)\n", __func__, read_buf, node->key_name, node->value, read_buf, (int) ret);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: read value data (%s) != expected value data (filename=\"%s\", data=\"%s\", read_buf=\"%s\", ret=%d)\n", __func__, read_buf, node->filename, node->value, read_buf, (int) ret);
TEST_ASSERT_MESSAGE(strncmp(read_buf, node->value, strlen(node->value)) == 0, fsfat_fopen_utest_msg_g);
if(read_buf){
free(read_buf);
}
ret = fclose(fp);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Close() call failed (ret=%d, errno=%d).\n", __func__, (int) ret, errno);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: fclose() call failed (ret=%d, errno=%d).\n", __func__, (int) ret, errno);
TEST_ASSERT_MESSAGE(ret == 0, fsfat_fopen_utest_msg_g);
return CaseNext;
}
#ifdef NOT_DEFINED
static fsfat_kv_data_t fsfat_fopen_test_02_data[] = {
FSFAT_INIT_1_TABLE_MID_NODE,
{ NULL, NULL},
};
/**
* @brief test to open() a pre-existing key and try to write it, which should fail
* @brief test to fopen() a pre-existing key and try to write it, which should fail
* as by default pre-existing keys are opened read-only
*
* Basic open test which does the following:
* - creates KV with default rw perms and writes some data to the value blob.
* - closes the newly created KV.
* - opens the KV with the default permissions (read-only)
* - tries to write the KV data which should fail because KV was not opened with write flag set.
* - creates file with default rw perms and writes some data to the value blob.
* - closes the newly created file.
* - opens the file with the default permissions (read-only)
* - tries to write the file data which should fail because file was not opened with write flag set.
* - closes the opened key
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
control_t fsfat_fopen_test_02(const size_t call_count)
{
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_SIZE len = 0;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_KEYDESC kdesc;
ARM_FSFAT_HANDLE_INIT(hkey);
ARM_FSFAT_FMODE flags;
int32_t ret = -1;
size_t len = 0;
FILE *fp = NULL;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
(void) call_count;
memset(&kdesc, 0, sizeof(kdesc));
/* dont set any flags to get default settings */
memset(&flags, 0, sizeof(flags));
kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
len = strlen(fsfat_fopen_test_02_data[0].value);
ret = fsfat_test_create(fsfat_fopen_test_02_data[0].key_name, (char*) fsfat_fopen_test_02_data[0].value, &len, &kdesc);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store (ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
ret = fsfat_test_create(fsfat_fopen_test_02_data[0].filename, (char*) fsfat_fopen_test_02_data[0].value, len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create file (ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
/* by default, owner of key opens with read-only permissions*/
ret = fopen(fsfat_fopen_test_02_data[0].key_name, "w+");
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open node (filename=\"%s\")(ret=%d)\n", __func__, fsfat_fopen_test_02_data[0].key_name, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
fp = fopen(fsfat_fopen_test_02_data[0].filename, "r");
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open file (filename=\"%s\", ret=%d)\n", __func__, fsfat_fopen_test_02_data[0].filename, (int) ret);
TEST_ASSERT_MESSAGE(fp != NULL, fsfat_fopen_utest_msg_g);
len = strlen(fsfat_fopen_test_02_data[0].value);
ret = drv->Write(hkey, fsfat_fopen_test_02_data[0].value, &len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: call to Write() succeeded when should have failed (filename=\"%s\")(ret=%d).\n", __func__, fsfat_fopen_test_02_data[0].key_name, (int) ret);
TEST_ASSERT_MESSAGE(ret == ARM_FSFAT_DRIVER_ERROR_KEY_READ_ONLY, fsfat_fopen_utest_msg_g);
ret = fwrite((const void*) fsfat_fopen_test_02_data[0].value, len, 1, fp);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: call to fwrite() succeeded when should have failed for read-only file (filename=\"%s\")(ret=%d).\n", __func__, fsfat_fopen_test_02_data[0].filename, (int) ret);
TEST_ASSERT_MESSAGE(ret <= 0, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Close() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(drv->Close(hkey) >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: fclose() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(fclose(fp) == 0, fsfat_fopen_utest_msg_g);
ret = drv->Uninitialize();
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
return CaseNext;
}
/**
* @brief test to open() a pre-existing key and try to write it, which should succeed
* @brief test to fopen() a pre-existing file and try to write it, which should succeed
* because the key was opened read-write permissions explicitly
*
* Basic open test which does the following:
* - creates KV with default rw perms and writes some data to the value blob.
* - closes the newly created KV.
* - opens the KV with the rw permissions (non default)
* - tries to write the KV data which should succeeds because KV was opened with write flag set.
* - creates file with default rw perms and writes some data to the value blob.
* - closes the newly created file.
* - opens the file with the rw permissions (non default)
* - tries to write the file data which should succeeds because file was opened with write flag set.
* - closes the opened key
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
control_t fsfat_fopen_test_03(const size_t call_count)
{
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_SIZE len = 0;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_KEYDESC kdesc;
ARM_FSFAT_HANDLE_INIT(hkey);
ARM_FSFAT_FMODE flags;
int32_t ret = -1;
size_t len = 0;
FILE *fp = NULL;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
(void) call_count;
memset(&kdesc, 0, sizeof(kdesc));
/* dont set any flags to get default settings */
memset(&flags, 0, sizeof(flags));
kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
len = strlen(fsfat_fopen_test_02_data[0].value);
ret = fsfat_test_create(fsfat_fopen_test_02_data[0].key_name, (char*) fsfat_fopen_test_02_data[0].value, &len, &kdesc);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store (ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
ret = fsfat_test_create(fsfat_fopen_test_02_data[0].filename, (char*) fsfat_fopen_test_02_data[0].value, len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create file in store (ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
/* opens with read-write permissions*/
flags.read = true;
flags.write = true;
ret = drv->Open(fsfat_fopen_test_02_data[0].key_name, flags, hkey);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open node (filename=\"%s\")(ret=%d)\n", __func__, fsfat_fopen_test_02_data[0].key_name, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
fp = fopen(fsfat_fopen_test_02_data[0].filename, "w+");
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open file (filename=\"%s\")(ret=%d)\n", __func__, fsfat_fopen_test_02_data[0].filename, (int) ret);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
len = strlen(fsfat_fopen_test_02_data[0].value);
ret = drv->Write(hkey, fsfat_fopen_test_02_data[0].value, &len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: call to Write() failed when should have succeeded (filename=\"%s\")(ret=%d).\n", __func__, fsfat_fopen_test_02_data[0].key_name, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
ret = fwrite((const void*) fsfat_fopen_test_02_data[0].value, len, 1, fp);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: call to fwrite() failed when should have succeeded (filename=\"%s\", ret=%d).\n", __func__, fsfat_fopen_test_02_data[0].filename, (int) ret);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Close() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(drv->Close(hkey) >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: fclose() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(fclose(fp) >= 0, fsfat_fopen_utest_msg_g);
/* clean-up */
ret = remove(fsfat_fopen_test_02_data[0].filename);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unable to delete file (filename=%s, ret=%d) .\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
ret = drv->Uninitialize();
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
return CaseNext;
}
/** @brief test to call fsfat_open() with a key_name string that exceeds
* the maximum length
/** @brief test to call fopen() with a filename string that exceeds the maximum length
* - chanFS supports the exFAT format which should support 255 char filenames
* - check that filenames of this length can be created
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
control_t fsfat_fopen_test_04(const size_t call_count)
{
char kv_name_good[FSFAT_KEY_NAME_MAX_LENGTH+1]; /* extra char for terminating null */
char kv_name_bad[FSFAT_KEY_NAME_MAX_LENGTH+2];
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_SIZE len = 0;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_KEYDESC kdesc;
ARM_FSFAT_FMODE flags;
char filename_good[FSFAT_FILENAME_MAX_LENGTH+1];
char filename_bad[FSFAT_FILENAME_MAX_LENGTH+2];
int32_t ret = -1;
size_t len = 0;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
(void) call_count;
memset(kv_name_good, 0, FSFAT_KEY_NAME_MAX_LENGTH+1);
memset(kv_name_bad, 0, FSFAT_KEY_NAME_MAX_LENGTH+2);
memset(&kdesc, 0, sizeof(kdesc));
/* dont set any flags to get default settings */
memset(&flags, 0, sizeof(flags));
len = FSFAT_KEY_NAME_MAX_LENGTH;
ret = fsfat_test_kv_name_gen(kv_name_good, len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name_good.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , fsfat_fopen_utest_msg_g);
memset(filename_good, 0, FSFAT_FILENAME_MAX_LENGTH+1);
memset(filename_bad, 0, FSFAT_FILENAME_MAX_LENGTH+2);
ret = fsfat_test_filename_gen(filename_good, FSFAT_FILENAME_MAX_LENGTH);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate filename_good.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: kv_name_good is not the correct length (len=%d, expected=%d).\n", __func__, (int) strlen(kv_name_good), (int) len);
TEST_ASSERT_MESSAGE(strlen(kv_name_good) == FSFAT_KEY_NAME_MAX_LENGTH, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: filename_good is not the correct length (filename_good=%s, len=%d, expected=%d).\n", __func__, filename_good, (int) strlen(filename_good), (int) FSFAT_FILENAME_MAX_LENGTH);
TEST_ASSERT_MESSAGE(strlen(filename_good) == FSFAT_FILENAME_MAX_LENGTH, fsfat_fopen_utest_msg_g);
ret = fsfat_test_create(kv_name_good, kv_name_good, &len, &kdesc);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store for kv_name_good(ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
ret = fsfat_test_filename_gen(filename_bad, FSFAT_FILENAME_MAX_LENGTH+1);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate filename_bad.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: filename_bad is not the correct length (len=%d, expected=%d).\n", __func__, (int) strlen(filename_bad), (int) FSFAT_FILENAME_MAX_LENGTH+1);
TEST_ASSERT_MESSAGE(strlen(filename_bad) == FSFAT_FILENAME_MAX_LENGTH+1, fsfat_fopen_utest_msg_g);
len = FSFAT_KEY_NAME_MAX_LENGTH+1;
ret = fsfat_test_kv_name_gen(kv_name_bad, len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name_bad.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , fsfat_fopen_utest_msg_g);
len = strlen(filename_good);
ret = fsfat_test_create(filename_good, filename_good, len);
/* FIXME:
* The current implementation can create file with a filename with 9 chars (more than the 8 restriction of FAT32 Short File Names).
* However, the exFAT 255 char filesnames is not supported and hence the following is commented out. Find out what is
* the supported max filename length and change this testcase according.
*
* FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create file (filename=%s, ret=%d).\n", __func__, filename_good, (int) ret);
* TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
*/
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: kv_name_bad is not the correct length (len=%d, expected=%d).\n", __func__, (int) strlen(kv_name_bad), (int) len);
TEST_ASSERT_MESSAGE(strlen(kv_name_bad) == FSFAT_KEY_NAME_MAX_LENGTH+1, fsfat_fopen_utest_msg_g);
memset(&kdesc, 0, sizeof(kdesc));
ret = fsfat_test_create(kv_name_bad, kv_name_bad, &len, &kdesc);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store for kv_name_bad when should have failed(ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
ret = drv->Uninitialize();
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
len = strlen(filename_bad);
ret = fsfat_test_create(filename_bad, filename_bad, len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: created file in store for filename_bad when should have failed (filename=%s, ret=%d).\n", __func__, filename_bad, (int) ret);
TEST_ASSERT_MESSAGE(ret < 0, fsfat_fopen_utest_msg_g);
return CaseNext;
}
/// @cond FSFAT_DOXYGEN_DISABLE
typedef struct fsfat_fopen_kv_name_ascii_node {
uint32_t code;
@ -536,23 +513,29 @@ static const uint32_t fsfat_fopen_kv_name_ascii_table_code_sentinel_g = 256;
/*@brief table recording ascii character codes permitted in kv names */
static fsfat_fopen_kv_name_ascii_node fsfat_fopen_kv_name_ascii_table[] =
{
{0, false}, /* codes 0-44 not allowed */
{45, true}, /* codes 45-46 == [-.] allowed */
{47, false}, /* code 47 not allowed */
{48, true}, /* codes 48-57 not allowed */
{58, false}, /* codes 46-64 not allowed */
{64, true}, /* codes 64-91 allowed [@A-Z] */
{91, false}, /* code 91-96 not allowed */
{95, true}, /* code 95 allowed '_' */
{96, false}, /* codes 96 not allowed */
{97, true}, /* codes 65-90 allowed [A-Z] and {*/
{123, false}, /* codes 123 '}' not allowed on its own*/
{124, false}, /* codes 124 not allowed */
{125, false}, /* code 125 '}' not allowed on its own*/
{126, false}, /* codes 126-255 not allowed */
{0 , true}, /* code 0-33 allowed*/
{34, false}, /* '"' not allowed */
{35, true}, /* allowed */
{42, false}, /* '*' not allowed */
{43, true}, /* allowed */
{47, false}, /* '/' not allowed */
{48, true}, /* allowed */
{58, false}, /* ':' not allowed */
{59, true}, /* allowed */
{60, false}, /* '<' not allowed */
{61, true}, /* allowed */
{62, false}, /* '?', '>' not allowed */
{64, true}, /* allowed */
{92, false}, /* '\' not allowed */
{93, true}, /* allowed */
{124, false}, /* '!' not allowed */
{125, true}, /* allowed */
{127, false}, /* DEL not allowed */
{128, true}, /* allowed */
{fsfat_fopen_kv_name_ascii_table_code_sentinel_g, false}, /* sentinel */
};
/// @cond FSFAT_DOXYGEN_DISABLE
enum fsfat_fopen_kv_name_pos {
fsfat_fopen_kv_name_pos_start = 0x0,
@ -562,11 +545,10 @@ enum fsfat_fopen_kv_name_pos {
};
/// @endcond
/** @brief test to call fsfat_open() with key_name that in includes
* illegal characters
* - the character(s) can be at the beginning of the key_name
* - the character(s) can be at the end of the key_name
* - the character(s) can be somewhere within the key_name string
/** @brief test to call fopen() with filename that in includes illegal characters
* - the character(s) can be at the beginning of the filename
* - the character(s) can be at the end of the filename
* - the character(s) can be somewhere within the filename string
* - a max-length string of random characters (legal and illegal)
* - a max-length string of random illegal characters only
*
@ -575,14 +557,17 @@ enum fsfat_fopen_kv_name_pos {
control_t fsfat_fopen_test_05(const size_t call_count)
{
bool f_allowed = false;
char kv_name[FSFAT_KEY_NAME_MAX_LENGTH+1]; /* extra char for terminating null */
const char *mnt_pt = "/sd";
const char *basename = "goodfile";
const char *extname = "txt";
const size_t basename_len = strlen(basename);
const size_t filename_len = strlen(mnt_pt)+strlen(basename)+strlen(extname)+2; /* extra 2 chars for '/' and '.' in "/sd/goodfile.txt" */
char filename[FSFAT_BUF_MAX_LENGTH];
size_t len = 0;
uint32_t j = 0;
int32_t ret = ARM_DRIVER_OK;
size_t name_len = FSFAT_KEY_NAME_MAX_LENGTH;
ARM_FSFAT_KEYDESC kdesc;
int32_t ret = 0;
fsfat_fopen_kv_name_ascii_node* node = NULL;
uint32_t pos;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
(void) call_count;
@ -594,42 +579,38 @@ control_t fsfat_fopen_test_05(const size_t call_count)
/* create bad keyname strings with invalid character code at start of keyname */
node = fsfat_fopen_kv_name_ascii_table;
memset(filename, 0, FSFAT_BUF_MAX_LENGTH);
while(node->code != fsfat_fopen_kv_name_ascii_table_code_sentinel_g)
{
/* loop over range */
for(j = node->code; j < (node+1)->code; j++)
{
if( (j >= 48 && j <= 57) || (j >= 65 && j <= 90) || (j >= 97 && j <= 122)) {
FSFAT_DBGLOG("%s: skipping alpha-numeric ascii character code %d (%c).\n", __func__, (int) j, j);
continue;
}
/* set the start, mid, last character of the name to the test char code */
for(pos = (uint32_t) fsfat_fopen_kv_name_pos_start; pos < (uint32_t) fsfat_fopen_kv_name_pos_max; pos++)
{
name_len = FSFAT_KEY_NAME_MAX_LENGTH;
memset(kv_name, 0, FSFAT_KEY_NAME_MAX_LENGTH+1);
memset(&kdesc, 0, sizeof(kdesc));
kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
ret = fsfat_test_kv_name_gen(kv_name, name_len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: kv_name incorrect length (len=%d, expected= %d).\n", __func__, (int) strlen(kv_name), (int) name_len);
TEST_ASSERT_MESSAGE(strlen(kv_name) == name_len, fsfat_fopen_utest_msg_g);
/* overwrite a char at the pos start, mid, end of the kv_name with an ascii char code (both illegal and legal)*/
len = snprintf(filename, filename_len+1, "%s/%s.%s", mnt_pt, basename, extname);
/* overwrite a char at the pos start, mid, end of the filename with an ascii char code (both illegal and legal)*/
switch(pos)
{
case fsfat_fopen_kv_name_pos_start:
kv_name[0] = (char) j;
filename[5] = (char) j; /* 5 so at to write the second basename char (bad chars as first char not accepted)*/
break;
case fsfat_fopen_kv_name_pos_mid:
/* create bad keyname strings with invalid character code in the middle of keyname */
kv_name[name_len/2] = (char) j;
filename[5+basename_len/2] = (char) j;
break;
case fsfat_fopen_kv_name_pos_end:
/* create bad keyname strings with invalid character code at end of keyname */
kv_name[name_len-1] = (char) j;
filename[5+basename_len-1] = (char) j;
break;
default:
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unexpected value of pos (pos=%d).\n", __func__, (int) pos);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
break;
}
@ -650,49 +631,49 @@ control_t fsfat_fopen_test_05(const size_t call_count)
break;
}
#endif
ret = fsfat_test_create(kv_name, kv_name, &name_len, &kdesc);
ret = fsfat_test_create(filename, (const char*) filename, len);
/* special cases */
switch(j)
{
case 0 :
case 46 :
switch(pos)
{
/* for code = 0 (null terminator). permitted at mid and end of string */
/* for code = 46 ('.'). permitted at mid and end of string but not at start */
case fsfat_fopen_kv_name_pos_start:
f_allowed = false;
break;
case fsfat_fopen_kv_name_pos_mid:
case fsfat_fopen_kv_name_pos_end:
default:
f_allowed = true;
break;
}
break;
//case 0 :
//case 46 :
// switch(pos)
// {
// /* for code = 0 (null terminator). permitted at mid and end of string */
// /* for code = 46 ('.'). permitted at mid and end of string but not at start */
// case fsfat_fopen_kv_name_pos_start:
// f_allowed = false;
// break;
// case fsfat_fopen_kv_name_pos_mid:
// case fsfat_fopen_kv_name_pos_end:
// default:
// f_allowed = true;
// break;
// }
// break;
default:
f_allowed = node->f_allowed;
break;
}
if(f_allowed == true)
{
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store when kv_name contains valid characters (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create file in store when filename contains valid characters (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
/* revert FSFAT_LOG for more trace */
FSFAT_DBGLOG("Successfully created a KV with valid keyname containing ascii character code %d (%c) at the %s of the keyname.\n", (int) j, (int) j, pos_str);
FSFAT_DBGLOG("Successfully created a file with valid keyname containing ascii character code %d (%c) at the %s of the keyname.\n", (int) j, (int) j, pos_str);
FSFAT_LOG("%c", '.');
ret = fsfat_test_delete(kv_name);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to delete KV previously created (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
ret = fsfat_test_delete(filename);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: failed to delete file previously created (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
TEST_ASSERT_MESSAGE(ret >= 0, fsfat_fopen_utest_msg_g);
}
else
{ /*node->f_allowed == false => not allowed to create kv name with ascii code */
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store when kv_name contains an invalid character (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: created file in store when filename contains an invalid character (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
TEST_ASSERT_MESSAGE(ret < 0, fsfat_fopen_utest_msg_g);
/* revert FSFAT_LOG for more trace */
FSFAT_DBGLOG("Successfully failed to create a KV with an invalid keyname containing ascii character code %d at the %s of the keyname.\n", (int) j, pos_str);
FSFAT_DBGLOG("Successfully failed to create a file with an invalid keyname containing ascii character code %d at the %s of the keyname.\n", (int) j, pos_str);
FSFAT_LOG("%c", '.');
}
}
@ -701,15 +682,13 @@ control_t fsfat_fopen_test_05(const size_t call_count)
}
FSFAT_LOG("%c", '\n');
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(drv->Uninitialize() >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
return CaseNext;
}
static const char fsfat_fopen_ascii_illegal_buf_g[] = "!\"<EFBFBD>$%&'()*+,./:;<=>?@[\\]^_`{|}~"; /* 31 chars */
static const char fsfat_fopen_ascii_illegal_buf_g[] = "\"<EFBFBD>'*+,./:;<=>?[\\]|";
/** @brief test to call fsfat_open() with key_name that in includes
/** @brief test to call fopen() with filename that in includes
* illegal characters
* - a max-length string of random illegal characters only
*
@ -717,93 +696,53 @@ static const char fsfat_fopen_ascii_illegal_buf_g[] = "!\"<22>$%&'()*+,./:;<=>?@[
*/
control_t fsfat_fopen_test_06(const size_t call_count)
{
char kv_name[FSFAT_KEY_NAME_MAX_LENGTH+1]; /* extra char for terminating null */
size_t i = 0;
const char *mnt_pt = "/sd";
const char *extname = "txt";
const size_t filename_len = strlen(mnt_pt)+FSFAT_MAX_FILE_BASENAME+strlen(extname)+2; /* extra 2 chars for '/' and '.' in "/sd/goodfile.txt" */
char filename[FSFAT_BUF_MAX_LENGTH];
int32_t i = 0;
int32_t j = 0;
uint32_t pos = 0;
int32_t ret = ARM_DRIVER_OK;
size_t name_len = FSFAT_KEY_NAME_MAX_LENGTH;
ARM_FSFAT_KEYDESC kdesc;
uint32_t len = 0;
int32_t ret = -1;
size_t buf_data_max = 0;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
(void) call_count;
memset(filename, 0, FSFAT_BUF_MAX_LENGTH);
/* create bad keyname strings with invalid character code at start of keyname */
buf_data_max = strlen(fsfat_fopen_ascii_illegal_buf_g);
name_len = FSFAT_KEY_NAME_MAX_LENGTH;
memset(kv_name, 0, FSFAT_KEY_NAME_MAX_LENGTH+1);
kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
/* generate a kv name of illegal chars*/
for(i = 0; i < name_len; i++)
{
pos = rand() % (buf_data_max+1);
kv_name[i] = fsfat_fopen_ascii_illegal_buf_g[pos];
/* generate a number of illegal filenames */
for (j = 0; i < FSFAT_MAX_FILE_BASENAME; j++) {
/* generate a kv name of illegal chars*/
len = snprintf(filename, filename_len+1, "%s/", mnt_pt);
for (i = 0; i < FSFAT_MAX_FILE_BASENAME; i++) {
pos = rand() % (buf_data_max+1);
len += snprintf(filename+len, filename_len+1, "%c", fsfat_fopen_ascii_illegal_buf_g[pos]);
}
len += snprintf(filename+len, filename_len+1, ".%s", extname);
ret = fsfat_test_create(filename, filename, len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: created file when filename contains invalid characters (filename=%s, ret=%d).\n", __func__, filename, (int) ret);
TEST_ASSERT_MESSAGE(ret < 0, fsfat_fopen_utest_msg_g);
}
ret = fsfat_test_create(kv_name, kv_name, &name_len, &kdesc);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store when kv_name contains invalid characters (ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(drv->Uninitialize() >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
return CaseNext;
}
/** @brief test to call fsfat_open() with key_name that in includes
* illegal characters
* - a max-length string of random characters (legal and illegal)
*
* @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
*/
control_t fsfat_fopen_test_07(const size_t call_count)
{
char kv_name[FSFAT_KEY_NAME_MAX_LENGTH+1]; /* extra char for terminating null */
size_t i = 0;
int32_t ret = ARM_DRIVER_OK;
size_t name_len = FSFAT_KEY_NAME_MAX_LENGTH;
ARM_FSFAT_KEYDESC kdesc;
size_t buf_data_max = 0;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
FSFAT_FENTRYLOG("%s:entered\n", __func__);
(void) call_count;
/* create bad keyname strings with invalid character code at start of keyname */
buf_data_max = strlen(fsfat_fopen_ascii_illegal_buf_g);
name_len = FSFAT_KEY_NAME_MAX_LENGTH;
memset(kv_name, 0, FSFAT_KEY_NAME_MAX_LENGTH+1);
kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
ret = fsfat_test_kv_name_gen(kv_name, name_len);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name.\n", __func__);
TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , fsfat_fopen_utest_msg_g);
/* pepper the illegal chars across the string*/
for(i++; i < buf_data_max; i++){
kv_name[rand() % (name_len+1)] = fsfat_fopen_ascii_illegal_buf_g[i];
}
ret = fsfat_test_create(kv_name, kv_name, &name_len, &kdesc);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store when kv_name contains invalid characters (ret=%d).\n", __func__, (int) ret);
TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
FSFAT_TEST_UTEST_MESSAGE(fsfat_fopen_utest_msg_g, FSFAT_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
TEST_ASSERT_MESSAGE(drv->Uninitialize() >= ARM_DRIVER_OK, fsfat_fopen_utest_msg_g);
return CaseNext;
}
#endif // NOT_DEFINED
#else
//todo: remove this and replace with memfile use?
#define FSFAT_FOPEN_TEST_01 fsfat_fopen_test_dummy
#define FSFAT_FOPEN_TEST_02 fsfat_fopen_test_dummy
#define FSFAT_FOPEN_TEST_03 fsfat_fopen_test_dummy
#define FSFAT_FOPEN_TEST_04 fsfat_fopen_test_dummy
#define FSFAT_FOPEN_TEST_05 fsfat_fopen_test_dummy
#define FSFAT_FOPEN_TEST_06 fsfat_fopen_test_dummy
#define FSFAT_FOPEN_TEST_07 fsfat_fopen_test_dummy
/** @brief fsfat_fopen_test_dummy Dummy test case for testing when platform doesnt have an SDCard installed.
*
@ -828,17 +767,12 @@ utest::v1::status_t greentea_setup(const size_t number_of_cases)
Case cases[] = {
/* 1 2 3 4 5 6 7 */
/* 1234567890123456789012345678901234567890123456789012345678901234567890 */
Case("FOPEN_test_01", FSFAT_FOPEN_TEST_01)
#ifdef NOT_DEFINED
Case("FOPEN_test_02", FSFAT_FOPEN_TEST_02),
Case("FOPEN_test_03", FSFAT_FOPEN_TEST_03),
Case("FOPEN_test_04", FSFAT_FOPEN_TEST_04),
Case("FOPEN_test_05", FSFAT_FOPEN_TEST_05),
Case("FOPEN_test_06", FSFAT_FOPEN_TEST_06),
Case("FOPEN_test_07", FSFAT_FOPEN_TEST_07),
#endif // NOT_DEFINED
Case("FSFAT_FOPEN_TEST_01: fopen()/fwrite()/fclose() directories/file in multi-dir filepath.", FSFAT_FOPEN_TEST_01),
Case("FSFAT_FOPEN_TEST_02: fopen(r) pre-existing file try to write it.", FSFAT_FOPEN_TEST_02),
Case("FSFAT_FOPEN_TEST_03: fopen(w+) pre-existing file try to write it.", FSFAT_FOPEN_TEST_03),
Case("FSFAT_FOPEN_TEST_04: fopen() with a filename exceeding the maximum length.", FSFAT_FOPEN_TEST_04),
Case("FSFAT_FOPEN_TEST_05: fopen() with filenames including illegal characters.", FSFAT_FOPEN_TEST_05),
Case("FSFAT_FOPEN_TEST_06", FSFAT_FOPEN_TEST_06)
};

4
features/filesystem/test/fsfat_debug.h
View File

@ -28,7 +28,9 @@
printf(_fmt, __VA_ARGS__); \
}while(0);
#define noFSFAT_DEBUG
//#define noFSFAT_DEBUG
// todo: remove next line
#define FSFAT_DEBUG
#ifdef FSFAT_DEBUG

336
features/filesystem/test/fsfat_test.c
View File

@ -31,7 +31,9 @@
#ifdef FSFAT_DEBUG
uint32_t fsfat_optDebug_g = 1;
uint32_t fsfat_optLogLevel_g = FSFAT_LOG_NONE; /*FSFAT_LOG_NONE|FSFAT_LOG_ERR|FSFAT_LOG_DEBUG|FSFAT_LOG_FENTRY */
// todo: revert change
//uint32_t fsfat_optLogLevel_g = FSFAT_LOG_NONE; /*FSFAT_LOG_NONE|FSFAT_LOG_ERR|FSFAT_LOG_DEBUG|FSFAT_LOG_FENTRY */
uint32_t fsfat_optLogLevel_g = FSFAT_LOG_FENTRY; /*FSFAT_LOG_NONE|FSFAT_LOG_ERR|FSFAT_LOG_DEBUG|FSFAT_LOG_FENTRY */
#endif
/* ruler for measuring text strings */
@ -92,259 +94,32 @@ fsfat_test_rw_data_entry_t fsfat_test_rw_data_table[] =
};
/* @brief test utility function to delete the file identified by filename
*/
int32_t fsfat_test_delete(const char* filename)
{
FSFAT_FENTRYLOG("%s:entered.\r\n", __func__);
return remove(filename);
}
//todo: delete
#ifdef NOT_DEFINED
static int32_t fsfat_test_dump_print_array(const char* data, ARM_FSFAT_SIZE len)
{
int i;
char buf[80];
char sbuf[80];
char* outbuf = buf;
char* soutbuf = sbuf;
memset(outbuf, 0, 80);
memset(soutbuf, 0, 80);
outbuf += sprintf(outbuf, " ");
soutbuf += sprintf(soutbuf, " ");
for (i = 0; i < (int) len; i++){
outbuf += sprintf(outbuf, "%02X ", data[i]);
if( !(isalnum( (int) data[i]) || ispunct( (int) data[i])) ){
*soutbuf++ = '*';
} else {
*soutbuf++ = data[i];
}
if( (i % 16 == 0) && i > 0){
FSFAT_LOG("%s", buf);
FSFAT_LOG("%s\n", sbuf);
outbuf = buf;
soutbuf = sbuf;
memset(outbuf, 0, 80);
memset(soutbuf, 0, 80);
outbuf += sprintf(outbuf, " ");
soutbuf += sprintf(soutbuf, " ");
}
}
if(i % 16){
/* Pad the end of the string to align string data. */
while(i % 16){
outbuf += sprintf(outbuf, " ");
i++;
}
FSFAT_LOG("%s", buf);
FSFAT_LOG(" %s", sbuf);
}
FSFAT_LOG("%s", "\n");
return ARM_DRIVER_OK;
}
/* @brief function to dump contents of cfstore
*/
int32_t fsfat_test_dump(void)
{
const char* key_name_query = "*";
char* read_buf = NULL;
char key_name[FSFAT_KEY_NAME_MAX_LENGTH+1];
uint8_t len = FSFAT_KEY_NAME_MAX_LENGTH+1;
ARM_FSFAT_SIZE vlen = 0;
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_HANDLE_INIT(next);
ARM_FSFAT_HANDLE_INIT(prev);
ARM_FSFAT_CAPABILITIES caps = fsfat_driver.GetCapabilities();
FSFAT_FENTRYLOG("%s:entered\n", __func__);
FSFAT_LOG("FSFAT Flash Entries%s", "\n");
FSFAT_LOG("=====================%s", "\n\n");
while((ret = drv->Find(key_name_query, prev, next)) == ARM_DRIVER_OK)
{
len = FSFAT_KEY_NAME_MAX_LENGTH+1;
ret = drv->GetKeyName(next, key_name, &len);
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("Error: failed to get key name%s", "\n");
break;
}
ret = drv->GetValueLen(next, &vlen);
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("Error: failed to get value length%s", "\n");
break;
}
read_buf = (char*) malloc(vlen+1);
if(read_buf == NULL){
FSFAT_ERRLOG("Error: failed to malloc() read buffer%s", "\n");
break;
}
ret = drv->Read(next, read_buf, &vlen);
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("Error: failed to read key value%s", "\n");
free(read_buf);
break;
}
FSFAT_LOG(" keyname : %s\n", key_name);
FSFAT_LOG(" name len : %d\n", (int) len);
FSFAT_LOG(" value len : %d\n", (int) vlen);
FSFAT_LOG(" data :%s", "\n");
fsfat_test_dump_print_array((const char*) read_buf, vlen);
FSFAT_LOG("%s", ".\n");
free(read_buf);
FSFAT_HANDLE_SWAP(prev, next);
}
FSFAT_LOG("%s", ".\n");
FSFAT_LOG(" caps.asynchronous_ops : %d\n", (int) caps.asynchronous_ops);
FSFAT_LOG("%s", ".\n");
FSFAT_LOG("== End ==============%s", "\n\n");
if(ret == ARM_FSFAT_DRIVER_ERROR_KEY_NOT_FOUND) {
/* As expected, no more keys have been found by the Find(). */
ret = ARM_DRIVER_OK;
}
return ret;
}
/* @brief test startup code to reset flash
*/
int32_t fsfat_test_startup(void)
{
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_DRIVER* fsfat_drv = &fsfat_driver;
ARM_FSFAT_CAPABILITIES caps = fsfat_driver.GetCapabilities();
FSFAT_LOG("INITIALIZING: caps.asynchronous_ops=%d\n", (int) caps.asynchronous_ops);
/* Dump contents of FSFAT */
ret = fsfat_drv->Initialize(NULL, NULL);
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("%s:Error: failed to initialize FSFAT (ret=%d)\n", __func__, (int) ret);
return ARM_DRIVER_ERROR;
}
ret = fsfat_test_dump();
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("%s:Error: failed to dump FSFAT (ret=%d)\n", __func__, (int) ret);
return ARM_DRIVER_ERROR;
}
ret = fsfat_drv->Uninitialize();
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("%s:Error: failed to uninitialize FSFAT (ret=%d)\n", __func__, (int) ret);
return ARM_DRIVER_ERROR;
}
#ifdef FSFAT_CONFIG_BACKEND_FLASH_ENABLED
static FlashJournal_t jrnl;
extern ARM_DRIVER_STORAGE ARM_Driver_Storage_MTD_K64F;
const ARM_DRIVER_STORAGE *drv = &ARM_Driver_Storage_MTD_K64F;
ret = FlashJournal_initialize(&jrnl, drv, &FLASH_JOURNAL_STRATEGY_SEQUENTIAL, NULL);
if(ret < JOURNAL_STATUS_OK){
FSFAT_ERRLOG("%s:Error: failed to initialize flash journaling layer (ret=%d)\n", __func__, (int) ret);
return ARM_DRIVER_ERROR;
}
ret = FlashJournal_reset(&jrnl);
if(ret < JOURNAL_STATUS_OK){
FSFAT_ERRLOG("%s:Error: failed to reset flash journal (ret=%d)\n", __func__, (int) ret);
return ARM_DRIVER_ERROR;
}
#endif /* FSFAT_CONFIG_BACKEND_FLASH_ENABLED */
return ARM_DRIVER_OK;
}
/* @brief test utility function to check a node appears correctly in the cfstore
* @note this function expects cfstore to have been initialised with
* a call to ARM_FSFAT_DRIVER::Initialize()
*/
int32_t fsfat_test_check_node_correct(const fsfat_kv_data_t* node)
{
char* read_buf;
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_SIZE len = 0;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_HANDLE_INIT(hkey);
ARM_FSFAT_FMODE flags;
FSFAT_FENTRYLOG("%s:entered\r\n", __func__);
memset(&flags, 0, sizeof(flags));
ret = drv->Open(node->key_name, flags, hkey);
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("%s:Error: failed to open node (key_name=\"%s\", value=\"%s\")(ret=%d)\r\n", __func__, node->key_name, node->value, (int) ret);
goto out0;
}
len = strlen(node->value) + 1;
read_buf = (char*) malloc(len);
if(read_buf == NULL) {
FSFAT_ERRLOG("%s:Error: failed to allocated read buffer \r\n", __func__);
goto out1;
}
memset(read_buf, 0, len);
ret = drv->Read(hkey, read_buf, &len);
if(ret < ARM_DRIVER_OK){
FSFAT_ERRLOG("%s:Error: failed to write key (key_name=\"%s\", value=\"%s\")\r\n", __func__, node->key_name, node->value);
goto out2;
}
/* check read data is as expected */
if(strncmp(read_buf, node->value, strlen(node->value)) != 0){
FSFAT_ERRLOG("%s:Error: read value data (%s) != KV value data (key_name=\"%s\", value=\"%s\")\r\n", __func__, read_buf, node->key_name, node->value);
ret = ARM_DRIVER_ERROR;
}
out2:
if(read_buf) free(read_buf);
out1:
drv->Close(hkey);
hkey = NULL;
out0:
return ret;
}
/* @brief test utility function to delete the cfstore key identified by key_name
* @note this function expects cfstore to have been initialised with
* a call to ARM_FSFAT_DRIVER::Initialize()
*/
int32_t fsfat_test_delete(const char* key_name)
{
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_HANDLE_INIT(hkey);
ARM_FSFAT_FMODE flags;
FSFAT_FENTRYLOG("%s:entered.\r\n", __func__);
memset(&flags, 0, sizeof(flags));
ret = drv->Open(key_name, flags, hkey);
if(ret < ARM_DRIVER_OK){
return ret;
}
if(hkey != NULL){
ret = drv->Delete(hkey);
drv->Close(hkey);
}
return ret;
}
/* @brief test utility function to delete all of the KVs in the cfstore
* @note this function expects cfstore to have been initialised with
* a call to ARM_FSFAT_DRIVER::Initialize()
/* @brief test utility function to delete all of the files in the filesystem
*/
int32_t fsfat_test_delete_all(void)
{
const char* key_name_query = "*";
char key_name[FSFAT_KEY_NAME_MAX_LENGTH+1];
uint8_t len = FSFAT_KEY_NAME_MAX_LENGTH+1;
int32_t ret = ARM_DRIVER_ERROR;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_HANDLE_INIT(next);
ARM_FSFAT_HANDLE_INIT(prev);
char key_name[FSFAT_FILENAME_MAX_LENGTH+1];
uint8_t len = FSFAT_FILENAME_MAX_LENGTH+1;
int32_t ret = -1;
FSFAT_FENTRYLOG("%s:entered.\r\n", __func__);
while((ret = drv->Find(key_name_query, prev, next)) == ARM_DRIVER_OK)
{
len = FSFAT_KEY_NAME_MAX_LENGTH+1;
len = FSFAT_FILENAME_MAX_LENGTH+1;
drv->GetKeyName(next, key_name, &len);
FSFAT_TP(FSFAT_TP_DELETE, "%s:deleting key_name=%s, len=%d\r\n", __func__, key_name, (int) len);
ret = drv->Delete(next);
@ -362,38 +137,36 @@ int32_t fsfat_test_delete_all(void)
return ret;
}
//#endif // NOT_DEFINED
#endif // NOT_DEFINED
/* @brief test utility function to create a file
*
* @param filename name of the file including path
* @param data data to store in file
* @param len number of bytes of data present in the data buffer.
*/
int32_t fsfat_test_create(const char* filename, const char* data, size_t* len)
int32_t fsfat_test_create(const char* filename, const char* data, size_t len)
{
int32_t ret = -1;
size_t value_len = 0;
FILE *fp = NULL;
FSFAT_FENTRYLOG("%s:entered.\r\n", __func__);
value_len = *len;
ret = fopen(filename, value_len, kdesc, hkey);
if(ret < ARM_DRIVER_OK){
FSFAT_FENTRYLOG("%s:entered (filename=%s, len=%d).\n", __func__, filename, (int) len);
fp = fopen(filename, "w+");
if(fp == NULL){
return ret;
}
value_len = *len;
ret = fwrite(hkey, data, &value_len);
if(ret < ARM_DRIVER_OK){
flose(hkey);
ret = fwrite((const void*) data, len, 1, fp);
if(ret < 0){
fclose(fp);
return ret;
}
if(value_len != *len){
fclose(hkey);
return ARM_DRIVER_ERROR;
}
flose(hkey);
fclose(fp);
return ret;
}
//#ifdef NOT_DEFINED
#ifdef NOT_DEFINED
/* @brief test utility function to create KVs from the supplied table
* @note this function expects cfstore to have been initialised with
@ -401,7 +174,7 @@ int32_t fsfat_test_create(const char* filename, const char* data, size_t* len)
*/
int32_t fsfat_test_create_table(const fsfat_kv_data_t* table)
{
int32_t ret = ARM_DRIVER_ERROR;
int32_t ret = -1;
ARM_FSFAT_SIZE len = 0;
fsfat_kv_data_t* node = NULL;
ARM_FSFAT_KEYDESC kdesc;
@ -494,10 +267,10 @@ fsfat_kv_data_t fsfat_test_init_1_data[] = {
int32_t fsfat_test_init_1(void)
{
char* read_buf = NULL;
const uint8_t key_name_max_len = FSFAT_KEY_NAME_MAX_LENGTH+1;
const uint8_t key_name_max_len = FSFAT_FILENAME_MAX_LENGTH+1;
uint8_t key_name_len = 0;
char key_name_buf[FSFAT_KEY_NAME_MAX_LENGTH+1];
int32_t ret = ARM_DRIVER_ERROR;
char key_name_buf[FSFAT_FILENAME_MAX_LENGTH+1];
int32_t ret = -1;
ARM_FSFAT_SIZE len = 0;
ARM_FSFAT_SIZE max_len = 0;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
@ -507,7 +280,7 @@ int32_t fsfat_test_init_1(void)
FSFAT_FENTRYLOG("%s:entered\r\n", __func__);
memset(&kdesc, 0, sizeof(kdesc));
memset(key_name_buf, 0, FSFAT_KEY_NAME_MAX_LENGTH+1);
memset(key_name_buf, 0, FSFAT_FILENAME_MAX_LENGTH+1);
/*scan for max length of value blob*/
node = fsfat_test_init_1_data;
@ -547,7 +320,7 @@ int32_t fsfat_test_init_1(void)
if(len != strlen(node->value)){
FSFAT_ERRLOG("%s:Error: failed to write full value data (key_name=\"%s\", value=\"%s\"), len=%d\r\n", __func__, node->key_name, node->value, (int) len);
drv->Close(hkey);
return ARM_DRIVER_ERROR;
return -1;
}
/* read the data back*/
len = strlen(node->value);
@ -561,7 +334,7 @@ int32_t fsfat_test_init_1(void)
if(len != strlen(node->value)){
FSFAT_ERRLOG("%s:Error: failed to read full value data (key_name=\"%s\", value=\"%s\"), len=%d, ret=%d\r\n", __func__, node->key_name, node->value, (int) len, (int) ret);
drv->Close(hkey);
return ARM_DRIVER_ERROR;
return -1;
}
key_name_len = key_name_max_len;
memset(key_name_buf, 0, key_name_len);
@ -569,7 +342,7 @@ int32_t fsfat_test_init_1(void)
if(len != strlen(node->value)){
FSFAT_ERRLOG("%s:Error: failed to GetKeyName() (key_name=\"%s\", value=\"%s\"), len=%d\r\n", __func__, node->key_name, node->value, (int) len);
drv->Close(hkey);
return ARM_DRIVER_ERROR;
return -1;
}
/* revert FSFAT_LOG for more trace */
FSFAT_DBGLOG("Created KV successfully (key_name=\"%s\", value=\"%s\")\r\n", key_name_buf, read_buf);
@ -588,7 +361,7 @@ int32_t fsfat_test_init_1(void)
int32_t fsfat_test_kv_is_found(const char* key_name, bool* bfound)
{
FSFAT_FENTRYLOG("%s:entered.\r\n", __func__);
int32_t ret = ARM_DRIVER_ERROR;
int32_t ret = -1;
ARM_FSFAT_HANDLE_INIT(prev);
ARM_FSFAT_HANDLE_INIT(next);
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
@ -606,34 +379,39 @@ int32_t fsfat_test_kv_is_found(const char* key_name, bool* bfound)
return ret;
}
#endif // NOT_DEFINED
/* @brief support function for generating a kv_name
* @param name buffer to hold kv name
* @param len length of kv name to generate
* @note braces are not included in the generated names as the names are
* of varible length and theyre may be unmatched
*
*/
#define FSFAT_TEST_KV_NAME_BUF_MAX_DATA (10+26+26+4)
int32_t fsfat_test_kv_name_gen(char* name, const size_t len)
int32_t fsfat_test_filename_gen(char* name, const size_t len)
{
size_t i;
const char buf[FSFAT_TEST_KV_NAME_BUF_MAX_DATA+1] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-_@";
uint32_t pos = 0;
const char* buf = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$-_@";
const int buf_len = strlen(buf);
FSFAT_FENTRYLOG("%s:entered\n", __func__);
for(i = 0; i < len; i++)
{
name[i] = buf[i % FSFAT_TEST_KV_NAME_BUF_MAX_DATA];
pos = rand() % (buf_len);
name[i] = buf[pos];
}
return ARM_DRIVER_OK;
return 0;
}
#ifdef NOT_DEFINED
/* @brief test utility function to read the value blob of a specified KV
* @note this function expects cfstore to have been initialised with
* a call to ARM_FSFAT_DRIVER::Initialize()
*/
int32_t fsfat_test_read(const char* key_name, char* data, ARM_FSFAT_SIZE* len)
{
int32_t ret = ARM_DRIVER_ERROR;
int32_t ret = -1;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_HANDLE_INIT(hkey);
ARM_FSFAT_FMODE flags;
@ -675,7 +453,7 @@ out0:
*/
int32_t fsfat_test_write(const char* key_name, const char* data, ARM_FSFAT_SIZE* len)
{
int32_t ret = ARM_DRIVER_ERROR;
int32_t ret = -1;
ARM_FSFAT_DRIVER* drv = &fsfat_driver;
ARM_FSFAT_HANDLE_INIT(hkey);
ARM_FSFAT_FMODE flags;

33
features/filesystem/test/fsfat_test.h
View File

@ -31,14 +31,19 @@ extern "C" {
//#include "configuration_store.h"
/* Defines */
#define FSFAT_INIT_1_TABLE_HEAD { "a", ""}
#define FSFAT_INIT_1_TABLE_MID_NODE { "0123456789abcdef0123456", "abcdefghijklmnopqrstuvwxyz"}
#define FSFAT_INIT_1_TABLE_TAIL { "yotta.hello-world.animal{wobbly-dog}{foot}backRight", "present"}
#define FSFAT_TEST_RW_TABLE_SENTINEL 0xffffffff
#define FSFAT_TEST_BYTE_DATA_TABLE_SIZE 256
#define FSFAT_UTEST_MSG_BUF_SIZE 256
#define FSFAT_UTEST_DEFAULT_TIMEOUT_MS 10000
#define FSFAT_MBED_HOSTTEST_TIMEOUT 60
#define FSFAT_INIT_1_TABLE_HEAD { "a", ""}
#define FSFAT_INIT_1_TABLE_MID_NODE { "/sd/01234567.txt", "abcdefghijklmnopqrstuvwxyz"}
#define FSFAT_INIT_1_TABLE_TAIL { "/sd/fopentst/hello/world/animal/wobbly/dog/foot/backrght.txt", "present"}
#define FSFAT_TEST_RW_TABLE_SENTINEL 0xffffffff
#define FSFAT_TEST_BYTE_DATA_TABLE_SIZE 256
#define FSFAT_UTEST_MSG_BUF_SIZE 256
#define FSFAT_UTEST_DEFAULT_TIMEOUT_MS 10000
#define FSFAT_MBED_HOSTTEST_TIMEOUT 60
#define FSFAT_MAX_FILE_BASENAME 8
#define FSFAT_MAX_FILE_EXTNAME 3
#define FSFAT_BUF_MAX_LENGTH 64
#define FSFAT_FILENAME_MAX_LENGTH 255
/* support macro for make string for utest _MESSAGE macros, which dont support formatted output */
#define FSFAT_TEST_UTEST_MESSAGE(_buf, _max_len, _fmt, ...) \
@ -54,7 +59,7 @@ extern "C" {
/* kv data for test */
typedef struct fsfat_kv_data_t {
const char* key_name;
const char* filename;
const char* value;
} fsfat_kv_data_t;
@ -70,19 +75,15 @@ extern fsfat_test_rw_data_entry_t fsfat_test_rw_data_table[];
extern const char* fsfat_test_opcode_str[];
extern const uint8_t fsfat_test_byte_data_table[FSFAT_TEST_BYTE_DATA_TABLE_SIZE];
int32_t fsfat_test_check_node_correct(const fsfat_kv_data_t* node);
//int32_t fsfat_test_create(const char* key_name, const char* data, size_t* len, ARM_FSFAT_KEYDESC* kdesc);
int32_t fsfat_test_create(const char* filename, const char* data, size_t len);
int32_t fsfat_test_create_table(const fsfat_kv_data_t* table);
int32_t fsfat_test_delete(const char* key_name);
int32_t fsfat_test_delete_all(void);
int32_t fsfat_test_dump(void);
int32_t fsfat_test_filename_found(const char* key_name, bool* bfound);
int32_t fsfat_test_filename_gen(char* name, const size_t len);
int32_t fsfat_test_init_1(void);
int32_t fsfat_test_kv_is_found(const char* key_name, bool* bfound);
int32_t fsfat_test_kv_name_gen(char* name, const size_t len);
int32_t fsfat_test_read(const char* key_name, char* data, size_t* len);
int32_t fsfat_test_startup(void);
int32_t fsfat_test_write(const char* key_name, const char* data, size_t* len);
#ifdef __cplusplus
}
#endif