/*
 * Copyright (c) 2020 Intel Corporation.
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @brief Test cases for filesystem api
 *
 * @defgroup filesystem_api File system API
 * @ingroup filesystem
 * @{
 * @}
 */

#include "test_fs.h"
#include <stdio.h>
#include <string.h>

struct fs_file_system_t null_fs = {NULL};

static struct test_fs_data test_data;
static struct fs_mount_t test_fs_mnt_1 = {
		.type = TEST_FS_1,
		.mnt_point = TEST_FS_MNTP,
		.fs_data = &test_data,
};

static struct fs_mount_t test_fs_mnt_already_mounted_same_data = {
		.type = TEST_FS_2,
		.mnt_point = "/OTHER",
		.fs_data = &test_data,
};

static struct test_fs_data test_data1;
static struct fs_mount_t test_fs_mnt_unsupported_fs = {
		.type = FS_TYPE_EXTERNAL_BASE,
		.mnt_point = "/MMCBLOCK:",
		.fs_data = &test_data1,
};

/* invalid name of mount point, not start with '/' */
static struct test_fs_data test_data2;
static struct fs_mount_t test_fs_mnt_invalid_root_1 = {
		.type = TEST_FS_2,
		.mnt_point = "SDA:",
		.fs_data = &test_data2,
};

/* length of the name of mount point is too short */
static struct test_fs_data test_data3;
static struct fs_mount_t test_fs_mnt_invalid_root_2 = {
		.type = TEST_FS_2,
		.mnt_point = "/",
		.fs_data = &test_data3,
};

/* NULL mount point */
static struct test_fs_data test_data4;
static struct fs_mount_t test_fs_mnt_invalid_root_3 = {
		.type = TEST_FS_2,
		.mnt_point = NULL,
		.fs_data = &test_data4,
};

static struct test_fs_data test_data5;
static struct fs_mount_t test_fs_mnt_already_mounted = {
		.type = TEST_FS_2,
		.mnt_point = TEST_FS_MNTP,
		.fs_data = &test_data5,
};

/* for test_fs, name of mount point must end with ':' */
static struct test_fs_data test_data6;
static struct fs_mount_t test_fs_mnt_invalid_mntp = {
		.type = TEST_FS_2,
		.mnt_point = "/SDA",
		.fs_data = &test_data6,
};

#define NOOP_MNTP "/SDCD:"
static struct test_fs_data test_data7;
static struct fs_mount_t test_fs_mnt_no_op = {
		.type = TEST_FS_2,
		.mnt_point = NOOP_MNTP,
		.fs_data = &test_data7,
};

static struct fs_file_t filep;
static struct fs_file_t err_filep;
static const char test_str[] = "hello world!";

/**
 * @brief Test fs_file_t_init initializer
 */
ZTEST(fs_api_dir_file, test_fs_file_t_init)
{
	struct fs_file_t fst;

	memset(&fst, 0xff, sizeof(fst));

	fs_file_t_init(&fst);
	zassert_equal(fst.mp, NULL, "Expected to be initialized to NULL");
	zassert_equal(fst.filep, NULL, "Expected to be initialized to NULL");
	zassert_equal(fst.flags, 0, "Expected to be initialized to 0");
}

/**
 * @brief Test fs_dir_t_init initializer
 */
ZTEST(fs_api_dir_file, test_fs_dir_t_init)
{
	struct fs_dir_t dirp;

	memset(&dirp, 0xff, sizeof(dirp));

	fs_dir_t_init(&dirp);
	zassert_equal(dirp.mp, NULL, "Expected to be initialized to NULL");
	zassert_equal(dirp.dirp, NULL, "Expected to be initialized to NULL");
}

/**
 * @brief Test mount interface of filesystem
 *
 * @details
 * Test fs_mount() interface in file system core
 * Following test cases depend on file systems mounted in this test case
 *
 * @ingroup filesystem_api
 */
void test_mount(void)
{
	int ret;

	TC_PRINT("\nmount tests:\n");
	TC_PRINT("Pass NULL pointer to fs_mount()\n");
	ret = fs_mount(NULL);
	zassert_not_equal(ret, 0, "Mount a NULL fs");

	TC_PRINT("Mount an unsupported file system\n");
	ret = fs_mount(&test_fs_mnt_unsupported_fs);
	zassert_not_equal(ret, 0, "Mount an unsupported fs");

	fs_register(TEST_FS_2, &temp_fs);

	TC_PRINT("Mount to an invalid directory\n");
	ret = fs_mount(&test_fs_mnt_invalid_root_1);
	zassert_not_equal(ret, 0, "Mount to an invalid dir");
	ret = fs_mount(&test_fs_mnt_invalid_root_2);
	zassert_not_equal(ret, 0, "Mount dir name too short");
	ret = fs_mount(&test_fs_mnt_invalid_root_3);
	zassert_not_equal(ret, 0, "Mount point is NULL");
	ret = fs_mount(&test_fs_mnt_invalid_mntp);
	zassert_not_equal(ret, 0, "Mount with invalid mount point");

	ret = fs_mount(&test_fs_mnt_1);
	zassert_equal(ret, 0, "Error mounting fs");

	TC_PRINT("Mount to a directory that has file system mounted already\n");
	ret = fs_mount(&test_fs_mnt_already_mounted);
	zassert_not_equal(ret, 0, "Mount to a mounted dir");

	TC_PRINT("Mount using same private data as already mounted system\n");
	ret = fs_mount(&test_fs_mnt_already_mounted_same_data);
	zassert_equal(ret, -EBUSY, "Re-mount using same data should have failed");

	fs_unregister(TEST_FS_2, &temp_fs);
	memset(&null_fs, 0, sizeof(null_fs));
	fs_register(TEST_FS_2, &null_fs);

	TC_PRINT("Mount a file system has no interface implemented\n");
	ret = fs_mount(&test_fs_mnt_no_op);
	zassert_not_equal(ret, 0, "Mount to a fs without op interface");

	/* mount an file system has no unmount functionality */
	null_fs.mount = temp_fs.mount;
	ret = fs_mount(&test_fs_mnt_no_op);
	zassert_equal(ret, 0, "fs has no unmount functionality can be mounted");
}

/**
 * @brief Test fs_unmount() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_unmount(void)
{
	int ret;

	TC_PRINT("\nunmount tests:\n");

	TC_PRINT("\nunmount nothing:\n");
	ret = fs_unmount(NULL);
	zassert_not_equal(ret, 0, "Unmount a NULL fs");

	TC_PRINT("\nunmount file system that has never been mounted:\n");
	ret = fs_unmount(&test_fs_mnt_unsupported_fs);
	zassert_not_equal(ret, 0, "Unmount a never mounted fs");

	ret = fs_unmount(&test_fs_mnt_1);
	zassert_true(ret >= 0, "Fail to unmount fs");

	TC_PRINT("\nunmount file system multiple times:\n");
	test_fs_mnt_1.fs = &temp_fs;
	ret = fs_unmount(&test_fs_mnt_1);
	zassert_not_equal(ret, 0, "Unmount an unmounted fs");

	TC_PRINT("unmount a file system has no unmount functionality\n");
	ret = fs_unmount(&test_fs_mnt_no_op);
	zassert_not_equal(ret, 0, "Unmount a fs has no unmount functionality");
	/* assign a unmount interface to null_fs to unmount it */
	null_fs.unmount = temp_fs.unmount;
	ret = fs_unmount(&test_fs_mnt_no_op);
	zassert_equal(ret, 0, "file system should be unmounted");
	/* TEST_FS_2 is registered in test_mount(), unregister it here */
	fs_unregister(TEST_FS_2, &null_fs);
}

/**
 * @brief Test fs_statvfs() interface in file system core
 *
 * @ingroup filesystem_api
 */
ZTEST(fs_api_dir_file, test_file_statvfs)
{
	struct fs_statvfs stat;
	int ret;

	ret = fs_statvfs(NULL, &stat);
	zassert_not_equal(ret, 0, "Pass NULL for path pointer");
	ret = fs_statvfs(TEST_FS_MNTP, NULL);
	zassert_not_equal(ret, 0, "Pass NULL for stat structure pointer");

	ret = fs_statvfs("/", &stat);
	zassert_not_equal(ret, 0, "Path name too short");

	ret = fs_statvfs("SDCARD:", &stat);
	zassert_not_equal(ret, 0, "Path name should start with /");

	ret = fs_statvfs("/SDCARD:", &stat);
	zassert_not_equal(ret, 0, "Get volume info by no-exist path");

	/* System with no statvfs interface */
	ret = fs_statvfs(NOOP_MNTP, &stat);
	zassert_equal(ret, -ENOTSUP, "fs has no statvfs functionality");

	ret = fs_statvfs(TEST_FS_MNTP, &stat);
	zassert_equal(ret, 0, "Error getting volume stats");
	TC_PRINT("\n");
	TC_PRINT("Optimal transfer block size   = %lu\n", stat.f_bsize);
	TC_PRINT("Allocation unit size          = %lu\n", stat.f_frsize);
	TC_PRINT("Volume size in f_frsize units = %lu\n", stat.f_blocks);
	TC_PRINT("Free space in f_frsize units  = %lu\n", stat.f_bfree);
}

/**
 * @brief Test fs_mkdir() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_mkdir(void)
{
	int ret;

	TC_PRINT("\nmkdir tests:\n");

	ret = fs_mkdir(NULL);
	zassert_not_equal(ret, 0, "Create a NULL directory");

	ret = fs_mkdir("d");
	zassert_not_equal(ret, 0, "Create dir with too short name");

	ret = fs_mkdir("SDCARD:/testdir");
	zassert_not_equal(ret, 0, "Create dir with wrong path");

	ret = fs_mkdir("/SDCARD:/testdir");
	zassert_not_equal(ret, 0, "Create dir in no fs mounted dir");

	ret = fs_mkdir(TEST_FS_MNTP);
	zassert_not_equal(ret, 0, "Should not create root dir");

	ret = fs_mkdir(NOOP_MNTP"/testdir");
	zassert_not_equal(ret, 0, "Filesystem has no mkdir interface");

	ret = fs_mkdir(TEST_DIR);
	zassert_equal(ret, 0, "Error creating dir");
}

/**
 * @brief Test fs_opendir() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_opendir(void)
{
	int ret;
	struct fs_dir_t dirp, dirp2, dirp3;

	TC_PRINT("\nopendir tests:\n");

	fs_dir_t_init(&dirp);
	fs_dir_t_init(&dirp2);
	fs_dir_t_init(&dirp3);

	TC_PRINT("Test null path\n");
	ret = fs_opendir(NULL, NULL);
	zassert_not_equal(ret, 0, "Open dir with NULL pointer parameter");

	TC_PRINT("Test directory without root path\n");
	ret = fs_opendir(&dirp, "ab");
	zassert_not_equal(ret, 0, "Can't open dir without root path");

	TC_PRINT("Test directory without name\n");
	ret = fs_opendir(&dirp, "");
	zassert_not_equal(ret, 0, "Can't open dir without path name");

	TC_PRINT("Test not existing mount point\n");
	ret = fs_opendir(&dirp, "/SDCARD:/test_dir");
	zassert_not_equal(ret, 0, "Open dir in an unmounted fs");

	TC_PRINT("Test filesystem has no opendir functionality\n");
	ret = fs_opendir(&dirp, NOOP_MNTP"/test_dir");
	zassert_not_equal(ret, 0, "Filesystem has no opendir functionality");

	TC_PRINT("Test root directory\n");
	ret = fs_opendir(&dirp, "/");
	zassert_equal(ret, 0, "Fail to open root dir");

	TC_PRINT("Double-open using occupied fs_dir_t object\n");
	ret = fs_opendir(&dirp, "/not_a_dir");
	zassert_equal(ret, -EBUSY, "Expected -EBUSY, got %d", ret);

	ret = fs_opendir(&dirp2, TEST_DIR);
	zassert_equal(ret, 0, "Fail to open dir");

	TC_PRINT("Double-open using occupied fs_dir_t object\n");
	ret = fs_opendir(&dirp2, "/xD");
	zassert_equal(ret, -EBUSY, "Expected -EBUSY, got %d", ret);

	mock_opendir_result(-EIO);
	TC_PRINT("Transfer underlying FS error\n");
	ret = fs_opendir(&dirp3, TEST_DIR);
	mock_opendir_result(0);
	zassert_equal(ret, -EIO, "FS error not transferred\n");
}

/**
 * @brief Test fs_close() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_closedir(void)
{
	int ret;
	struct fs_dir_t dirp;

	TC_PRINT("\nclosedir tests: %s\n", TEST_DIR);
	fs_dir_t_init(&dirp);
	ret = fs_opendir(&dirp, TEST_DIR);
	zassert_equal(ret, 0, "Fail to open dir");

	ret = fs_closedir(&dirp);
	zassert_equal(ret, 0, "Fail to close dir");

	dirp.mp = &test_fs_mnt_1;
	ret = fs_closedir(&dirp);
	zassert_not_equal(ret, 0, "Should no close a closed dir");

	dirp.mp = &test_fs_mnt_no_op;
	ret = fs_closedir(&dirp);
	zassert_not_equal(ret, 0, "Filesystem has no closedir interface");
}

/**
 * @brief Test Reuse fs_dir_t object from closed directory"
 *
 * @ingroup filesystem_api
 */
void test_opendir_closedir(void)
{
	int ret;
	struct fs_dir_t dirp;

	TC_PRINT("\nreuse fs_dir_t tests:\n");

	fs_dir_t_init(&dirp);

	TC_PRINT("Test: open root dir, close, open volume dir\n");
	ret = fs_opendir(&dirp, "/");
	zassert_equal(ret, 0, "Fail to open root dir");

	ret = fs_closedir(&dirp);
	zassert_equal(ret, 0, "Fail to close dir");

	ret = fs_opendir(&dirp, TEST_DIR);
	zassert_equal(ret, 0, "Fail to open dir");

	TC_PRINT("Test: open volume dir, close, open root dir\n");
	ret = fs_closedir(&dirp);
	zassert_equal(ret, 0, "Fail to close dir");

	ret = fs_opendir(&dirp, "/");
	zassert_equal(ret, 0, "Fail to open root dir");
}

static int _test_lsdir(const char *path)
{
	int ret;
	struct fs_dir_t dirp;
	struct fs_dirent entry;

	TC_PRINT("\nlsdir tests:\n");

	fs_dir_t_init(&dirp);
	memset(&entry, 0, sizeof(entry));

	TC_PRINT("read an unopened dir\n");
	dirp.dirp = "somepath";
	ret = fs_readdir(&dirp, &entry);
	if (!ret) {
		return TC_FAIL;
	}

	dirp.mp = &test_fs_mnt_no_op;
	ret = fs_readdir(&dirp, NULL);
	if (!ret) {
		return TC_FAIL;
	}

	dirp.mp = &test_fs_mnt_1;
	ret = fs_readdir(&dirp, NULL);
	if (!ret) {
		return TC_FAIL;
	}

	TC_PRINT("read an opened dir\n");
	fs_dir_t_init(&dirp);
	ret = fs_opendir(&dirp, path);
	if (ret) {
		if (path) {
			TC_PRINT("Error opening dir %s [%d]\n", path, ret);
		}
		return TC_FAIL;
	}

	TC_PRINT("\nListing dir %s:\n", path);
	for (;;) {
		ret = fs_readdir(&dirp, &entry);

		/* entry.name[0] == 0 means end-of-dir */
		if (ret || entry.name[0] == 0) {
			break;
		}

		if (entry.type == FS_DIR_ENTRY_DIR) {
			TC_PRINT("[DIR ] %s\n", entry.name);
		} else {
			TC_PRINT("[FILE] %s (size = %zu)\n",
				entry.name, entry.size);
		}
	}

	ret = fs_closedir(&dirp);
	if (ret) {
		TC_PRINT("Error close a directory\n");
		return TC_FAIL;
	}

	return ret;
}

/**
 * @brief Test fs_readdir() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_lsdir(void)
{
	zassert_true(_test_lsdir(NULL) == TC_FAIL);
	zassert_true(_test_lsdir("/") == TC_PASS);
	zassert_true(_test_lsdir("/test") == TC_FAIL);
	zassert_true(_test_lsdir(TEST_DIR) == TC_PASS);
}

/**
 * @brief Test fs_open() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_file_open(void)
{
	int ret;

	TC_PRINT("\nOpen tests:\n");
	fs_file_t_init(&filep);

	TC_PRINT("\nOpen a file without a path\n");
	ret = fs_open(&filep, NULL, FS_O_READ);
	zassert_not_equal(ret, 0, "Open a NULL file");

	TC_PRINT("\nOpen a file with wrong abs path\n");
	ret = fs_open(&filep, "/", FS_O_READ);
	zassert_not_equal(ret, 0, "Open a file with wrong path");

	TC_PRINT("\nOpen a file with wrong path\n");
	ret = fs_open(&filep, "test_file.txt", FS_O_READ);
	zassert_not_equal(ret, 0, "Open a file with wrong path");

	TC_PRINT("\nOpen a file with wrong abs path\n");
	ret = fs_open(&filep, "/test_file.txt", FS_O_READ);
	zassert_not_equal(ret, 0, "Open a file with wrong abs path");

	TC_PRINT("\nFilesystem has no open functionality\n");
	ret = fs_open(&filep, NOOP_MNTP"/test_file.txt", FS_O_READ);
	zassert_not_equal(ret, 0, "Filesystem has no open functionality");

	ret = fs_open(&filep, TEST_FILE, FS_O_READ);
	zassert_equal(ret, 0, "Fail to open file");

	TC_PRINT("\nDouble-open\n");
	ret = fs_open(&filep, TEST_FILE, FS_O_READ);
	zassert_equal(ret, -EBUSY, "Expected -EBUSY, got %d", ret);

	TC_PRINT("\nReopen the same file");
	ret = fs_open(&filep, TEST_FILE, FS_O_READ);
	zassert_not_equal(ret, 0, "Reopen an opened file");

	TC_PRINT("Opened file %s\n", TEST_FILE);
}

static int _test_file_write(void)
{
	ssize_t brw;
	int ret;

	TC_PRINT("\nWrite tests:\n");

	TC_PRINT("Write to an unopened file\n");
	fs_file_t_init(&err_filep);
	brw = fs_write(&err_filep, (char *)test_str, strlen(test_str));
	if (brw >= 0) {
		return TC_FAIL;
	}

	TC_PRINT("Write to filesystem has no write interface\n");
	err_filep.mp = &test_fs_mnt_no_op;
	brw = fs_write(&err_filep, (char *)test_str, strlen(test_str));
	if (brw >= 0) {
		return TC_FAIL;
	}

	ret = fs_seek(&filep, 0, FS_SEEK_SET);
	if (ret) {
		TC_PRINT("fs_seek failed [%d]\n", ret);
		fs_close(&filep);
		return ret;
	}

	TC_PRINT("Write to file from a invalid source\n");
	brw = fs_write(&filep, NULL, strlen(test_str));
	if (brw >= 0) {
		return TC_FAIL;
	}

	TC_PRINT("Data written:\"%s\"\n\n", test_str);

	brw = fs_write(&filep, (char *)test_str, strlen(test_str));
	if (brw < 0) {
		TC_PRINT("Failed writing to file [%zd]\n", brw);
		fs_close(&filep);
		return brw;
	}

	if (brw < strlen(test_str)) {
		TC_PRINT("Unable to complete write. Volume full.\n");
		TC_PRINT("Number of bytes written: [%zd]\n", brw);
		fs_close(&filep);
		return TC_FAIL;
	}

	TC_PRINT("Data successfully written!\n");

	return ret;
}

/**
 * @brief Test fs_write() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_file_write(void)
{
	zassert_true(_test_file_write() == TC_PASS);
}

static int _test_file_sync(void)
{
	int ret;
	ssize_t brw;

	TC_PRINT("\nSync tests:\n");

	TC_PRINT("sync an unopened file\n");
	fs_file_t_init(&err_filep);
	ret = fs_sync(&err_filep);
	if (!ret) {
		return TC_FAIL;
	}

	TC_PRINT("sync to filesystem has no sync functionality\n");
	err_filep.mp = &test_fs_mnt_no_op;
	ret = fs_sync(&err_filep);
	if (!ret) {
		return TC_FAIL;
	}

	fs_file_t_init(&filep);
	ret = fs_open(&filep, TEST_FILE, FS_O_RDWR);

	for (;;) {
		brw = fs_write(&filep, (char *)test_str, strlen(test_str));
		if (brw < strlen(test_str)) {
			break;
		}
		ret = fs_sync(&filep);
		if (ret) {
			TC_PRINT("Error syncing file [%d]\n", ret);
			fs_close(&filep);
			return ret;
		}

		ret = fs_tell(&filep);
		if (ret < 0) {
			TC_PRINT("Error tell file [%d]\n", ret);
			fs_close(&filep);
			return ret;
		}

	}

	TC_PRINT("Sync a overflowed file\n");
	ret = fs_sync(&filep);
	if (!ret) {
		fs_close(&filep);
		return TC_FAIL;
	}

	TC_PRINT("Tell a overflowed file\n");
	ret = fs_tell(&filep);
	if (!ret) {
		fs_close(&filep);
		return TC_FAIL;
	}

	fs_close(&filep);
	return TC_PASS;
}

/**
 * @brief Test fs_sync() interface in file system core
 *
 * @ingroup filesystem_api
 */
ZTEST(fs_api_dir_file, test_file_sync)
{
	zassert_true(_test_file_sync() == TC_PASS);
}

/**
 * @brief Test fs_read() interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_file_read(void)
{
	ssize_t brw;
	char read_buff[80];
	size_t sz = strlen(test_str);

	TC_PRINT("\nRead tests:\n");

	TC_PRINT("Read an unopened file\n");
	fs_file_t_init(&err_filep);
	brw = fs_read(&err_filep, read_buff, sz);
	zassert_false(brw >= 0, "Can't read an unopened file");

	TC_PRINT("Filesystem has no read interface\n");
	err_filep.mp = &test_fs_mnt_no_op;
	brw = fs_read(&err_filep, read_buff, sz);
	zassert_false(brw >= 0, "Filesystem has no read interface");

	TC_PRINT("Read to a invalid buffer\n");
	brw = fs_read(&filep, NULL, sz);
	zassert_false(brw >= 0, "Read data to a invalid buffer");

	brw = fs_read(&filep, read_buff, sz);
	zassert_true(brw >= 0, "Fail to read file");

	read_buff[brw] = 0;
	TC_PRINT("Data read:\"%s\"\n\n", read_buff);

	zassert_true(strcmp(test_str, read_buff) == 0,
		    "Error - Data read does not match data written");

	TC_PRINT("Data read matches data written\n");
}

/**
 * @brief fs_seek tests for expected ENOTSUP
 *
 * @ingroup filesystem_api
 */
void test_file_seek(void)
{
	struct fs_file_system_t backup = temp_fs;

	/* Simulate tell and lseek not implemented */
	temp_fs.lseek = NULL;
	temp_fs.tell = NULL;

	zassert_equal(fs_seek(&filep, 0, FS_SEEK_CUR),
		      -ENOTSUP,
		      "fs_seek not expected to be implemented");
	zassert_equal(fs_tell(&filep),
		      -ENOTSUP,
		      "fs_tell not expected to be implemented");

	/* Restore fs API interface */
	temp_fs = backup;
}

static int _test_file_truncate(void)
{
	int ret;
	off_t orig_pos;
	char read_buff[80];
	ssize_t brw;

	TC_PRINT("\nTruncate tests: max file size is 128byte\n");

	TC_PRINT("\nTruncate, seek, tell an unopened file\n");
	fs_file_t_init(&err_filep);
	ret = fs_truncate(&err_filep, 256);
	if (!ret) {
		return TC_FAIL;
	}
	ret = fs_seek(&err_filep, 0, FS_SEEK_END);
	if (!ret) {
		return TC_FAIL;
	}

	ret = fs_tell(&err_filep);
	if (!ret) {
		return TC_FAIL;
	}

	TC_PRINT("\nTruncate, seek, tell fs has no these functionality\n");
	err_filep.mp = &test_fs_mnt_no_op;
	ret = fs_truncate(&err_filep, 256);
	if (!ret) {
		return TC_FAIL;
	}
	ret = fs_seek(&err_filep, 0, FS_SEEK_END);
	if (!ret) {
		return TC_FAIL;
	}

	ret = fs_tell(&err_filep);
	if (!ret) {
		return TC_FAIL;
	}

	TC_PRINT("Truncating to size larger than 128byte\n");
	ret = fs_truncate(&filep, 256);
	if (!ret) {
		fs_close(&filep);
		return TC_FAIL;
	}

	/* Test truncating to 0 size */
	TC_PRINT("\nTesting shrink to 0 size\n");
	ret = fs_truncate(&filep, 0);
	if (ret) {
		TC_PRINT("fs_truncate failed [%d]\n", ret);
		fs_close(&filep);
		return ret;
	}

	TC_PRINT("File seek from invalid whence\n");
	ret = fs_seek(&filep, 0, 100);
	if (!ret) {
		fs_close(&filep);
		return TC_FAIL;
	}

	fs_seek(&filep, 0, FS_SEEK_END);
	if (fs_tell(&filep) > 0) {
		TC_PRINT("Failed truncating to size 0\n");
		fs_close(&filep);
		return TC_FAIL;
	}

	TC_PRINT("Testing write after truncating\n");
	ret = _test_file_write();
	if (ret) {
		TC_PRINT("Write failed after truncating\n");
		return ret;
	}

	fs_seek(&filep, 0, FS_SEEK_END);

	orig_pos = fs_tell(&filep);
	TC_PRINT("Original size of file = %d\n", (int)orig_pos);

	/* Test shrinking file */
	TC_PRINT("\nTesting shrinking\n");
	ret = fs_truncate(&filep, orig_pos - 5);
	if (ret) {
		TC_PRINT("fs_truncate failed [%d]\n", ret);
		fs_close(&filep);
		return ret;
	}

	fs_seek(&filep, 0, FS_SEEK_END);
	TC_PRINT("File size after shrinking by 5 bytes = %d\n",
						(int)fs_tell(&filep));
	if (fs_tell(&filep) != (orig_pos - 5)) {
		TC_PRINT("File size after fs_truncate not as expected\n");
		fs_close(&filep);
		return TC_FAIL;
	}

	/* Test expanding file */
	TC_PRINT("\nTesting expanding\n");
	fs_seek(&filep, 0, FS_SEEK_END);
	orig_pos = fs_tell(&filep);
	ret = fs_truncate(&filep, orig_pos + 10);
	if (ret) {
		TC_PRINT("fs_truncate failed [%d]\n", ret);
		fs_close(&filep);
		return ret;
	}

	fs_seek(&filep, 0, FS_SEEK_END);
	TC_PRINT("File size after expanding by 10 bytes = %d\n",
						(int)fs_tell(&filep));
	if (fs_tell(&filep) != (orig_pos + 10)) {
		TC_PRINT("File size after fs_truncate not as expected\n");
		fs_close(&filep);
		return TC_FAIL;
	}

	/* Check if expanded regions are zeroed */
	TC_PRINT("Testing for zeroes in expanded region\n");
	fs_seek(&filep, -5, FS_SEEK_END);

	brw = fs_read(&filep, read_buff, 5);

	if (brw < 5) {
		TC_PRINT("Read failed after truncating\n");
		fs_close(&filep);
		return -1;
	}

	for (int i = 0; i < 5; i++) {
		if (read_buff[i]) {
			TC_PRINT("Expanded regions are not zeroed\n");
			fs_close(&filep);
			return TC_FAIL;
		}
	}

	return TC_PASS;
}

/**
 * @brief Truncate the file to the new length and check
 *
 * @details
 * - fs_seek(), locate the position to truncate
 * - fs_truncate()
 * - fs_tell(), retrieve the current position
 *
 * @ingroup filesystem_api
 */
void test_file_truncate(void)
{
	zassert_true(_test_file_truncate() == TC_PASS);
}

/**
 * @brief Test close file interface in file system core
 *
 * @ingroup filesystem_api
 */
void test_file_close(void)
{
	int ret;

	TC_PRINT("\nClose tests:\n");

	TC_PRINT("Close an unopened file\n");
	fs_file_t_init(&err_filep);
	ret = fs_close(&err_filep);
	zassert_equal(ret, 0, "Should close an unopened file");

	TC_PRINT("Filesystem has no close interface\n");
	err_filep.mp = &test_fs_mnt_no_op;
	ret = fs_close(&err_filep);
	zassert_not_equal(ret, 0, "Filesystem has no close interface");

	ret = fs_close(&filep);
	zassert_equal(ret, 0, "Fail to close file");

	TC_PRINT("Reuse fs_file_t from closed file");
	ret = fs_open(&filep, TEST_FILE, FS_O_READ);
	zassert_equal(ret, 0, "Expected open to succeed, got %d", ret);
	ret = fs_close(&filep);
	zassert_equal(ret, 0, "Expected close to succeed, got %d", ret);

	TC_PRINT("\nClose a closed file:\n");
	filep.mp = &test_fs_mnt_1;
	ret = fs_close(&filep);
	zassert_not_equal(ret, 0, "Should not reclose a closed file");

	TC_PRINT("Closed file %s\n", TEST_FILE);
}

/**
 * @brief Test fs_rename() interface in file system core
 *
 * @ingroup filesystem_api
 */
ZTEST(fs_api_dir_file, test_file_rename)
{
	int ret = TC_FAIL;

	TC_PRINT("\nRename file tests:\n");

	ret = fs_rename(NULL, NULL);
	zassert_not_equal(ret, 0, "Rename a NULL file");

	ret = fs_rename("/", TEST_FILE_RN);
	zassert_not_equal(ret, 0, "source file name is too short");

	ret = fs_rename("testfile.txt", TEST_FILE_RN);
	zassert_not_equal(ret, 0, "source file name doesn't start with /");

	ret = fs_rename("/SDCARD:/testfile.txt", NULL);
	zassert_not_equal(ret, 0, "Rename to a NULL file");

	ret = fs_rename("/SDCARD:/testfile.txt", "/");
	zassert_not_equal(ret, 0, "dest file name too short");

	ret = fs_rename("/SDCARD:/testfile.txt", "rename.txt");
	zassert_not_equal(ret, 0, "dest file name doesn't start with /");

	ret = fs_rename("/SDCARD:/testfile.txt", TEST_FILE_RN);
	zassert_not_equal(ret, 0, "Rename a not existing file");

	ret = fs_rename(TEST_FILE, "/SDCARD:/testfile_renamed.txt");
	zassert_not_equal(ret, 0, "Rename file to different mount point");

	ret = fs_rename(TEST_FILE, TEST_FILE_EX);
	zassert_not_equal(ret, 0, "Rename file to an exist file");

	ret = fs_rename(NOOP_MNTP"/test.txt", NOOP_MNTP"/test_new.txt");
	zassert_not_equal(ret, 0, "Filesystem has no rename functionality");

	ret = fs_rename(TEST_FILE, TEST_FILE_RN);
	zassert_equal(ret, 0, "Fail to rename a file");
}

/**
 * @brief Test fs_stat() interface in filesystem core
 *
 * @ingroup filesystem_api
 */
ZTEST(fs_api_dir_file, test_file_stat)
{
	int ret;
	struct fs_dirent entry;

	TC_PRINT("\nStat file tests:\n");

	ret = fs_stat(NULL, &entry);
	zassert_not_equal(ret, 0, "Pointer to path is NULL");

	ret = fs_stat(TEST_DIR, NULL);
	zassert_not_equal(ret, 0, "Stat a dir without entry");

	ret = fs_stat("/", &entry);
	zassert_not_equal(ret, 0, "dir path name is too short");

	ret = fs_stat("SDCARD", &entry);
	zassert_not_equal(ret, 0, "Stat a dir path without /");

	ret = fs_stat("/SDCARD", &entry);
	zassert_not_equal(ret, 0, "Stat a not existing dir");

	ret = fs_stat(NOOP_MNTP, &entry);
	zassert_not_equal(ret, 0, "filesystem has no stat functionality");

	ret = fs_stat(TEST_DIR, &entry);
	zassert_equal(ret, 0, "Fail to stat a dir");

	ret = fs_stat(TEST_DIR_FILE, &entry);
	zassert_equal(ret, 0, "Fail to stat a file");
}

/**
 * @brief Test fs_unlink() interface in filesystem core
 *
 * @ingroup filesystem_api
 */
ZTEST(fs_api_dir_file, test_file_unlink)
{
	int ret;

	TC_PRINT("\nDelete tests:\n");

	ret = fs_unlink(NULL);
	zassert_not_equal(ret, 0, "Delete a NULL file");

	ret = fs_unlink("/");
	zassert_not_equal(ret, 0, "Delete a file with too short name");

	ret = fs_unlink("SDCARD:/test_file.txt");
	zassert_not_equal(ret, 0, "Delete a file with missing root / in path");

	ret = fs_unlink("/SDCARD:/test_file.txt");
	zassert_not_equal(ret, 0, "Delete a not existing file");

	ret = fs_unlink(TEST_FS_MNTP);
	zassert_not_equal(ret, 0, "Delete a root dir");

	ret = fs_unlink(NOOP_MNTP);
	zassert_not_equal(ret, 0, "Filesystem has no unlink functionality");

	/* In filesystem core, static function fs_get_mnt_point() check
	 * the length of mount point's name. It is not an API, test this
	 * function at this point because test_file_unlink() is the
	 * last test case before test_unmount(), change mountp_len of
	 * test_fs_mnt_no_op to 0 could not effect other test cases
	 */
	test_fs_mnt_no_op.mountp_len = 0;
	ret = fs_unlink(NOOP_MNTP);
	zassert_not_equal(ret, 0, "mount point with 0 mountp_len can't be get");

	ret = fs_unlink(TEST_FILE_RN);
	zassert_equal(ret, 0, "Fail to delete file");

	TC_PRINT("File (%s) deleted successfully!\n", TEST_FILE_RN);
}

static void *fs_api_setup(void)
{
	fs_register(TEST_FS_1, &temp_fs);
	fs_mount(&test_fs_mnt_1);
	memset(&null_fs, 0, sizeof(null_fs));
	null_fs.mount = temp_fs.mount;
	null_fs.unmount = temp_fs.unmount;
	fs_register(TEST_FS_2, &null_fs);
	fs_mount(&test_fs_mnt_no_op);
	return NULL;
}

static void fs_api_teardown(void *fixtrue)
{
	fs_unmount(&test_fs_mnt_no_op);
	fs_unregister(TEST_FS_2, &null_fs);
	fs_unmount(&test_fs_mnt_1);
	fs_unregister(TEST_FS_1, &temp_fs);
}

ZTEST(fs_api_dir_file, test_fs_dir)
{
	test_mkdir();
	test_opendir();
	test_closedir();
	test_opendir_closedir();
	test_lsdir();
}

ZTEST(fs_api_dir_file, test_file_ops)
{
	test_file_open();
	test_file_write();
	test_file_read();
	test_file_seek();
	test_file_truncate();
	test_file_close();
}

ZTEST(fs_api_register_mount, test_mount_unmount)
{
	fs_register(TEST_FS_1, &temp_fs);
	test_mount();
	test_unmount();
	fs_unregister(TEST_FS_1, &temp_fs);
}

ZTEST_SUITE(fs_api_register_mount, NULL, NULL, NULL, NULL, NULL);
ZTEST_SUITE(fs_api_dir_file, NULL, fs_api_setup, NULL, NULL, fs_api_teardown);