Ben / moon

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

#include "storage.h"
#include "test_harness.h"
#include "test_helpers.h"

static bool find_entry(const storage_entry_t* entries,
                       int count,
                       const char* name,
                       storage_entry_type_t type) {
	for (int i = 0; i < count; i++) {
		if (strcmp(entries[i].name, name) == 0 && entries[i].type == type) {
			return true;
		}
	}
	return false;
}

static bool test_storage_init_and_mount(void) {
	ASSERT_TRUE(storage_init());
	ASSERT_TRUE(storage_is_mounted());
	return true;
}

static bool test_storage_mkdir_and_list_dir(void) {
	ASSERT_TRUE(test_prepare_storage());
	ASSERT_TRUE(storage_mkdir(".tests/storage_case"));

	storage_file_t f = storage_open("/.tests/storage_case/file.txt", "w");
	ASSERT_TRUE(f != NULL);
	ASSERT_EQ_INT(5, (int)storage_write(f, "hello", 5));
	ASSERT_EQ_INT(0, storage_close(f));

	storage_entry_t entries[8];
	memset(entries, 0, sizeof(entries));
	int count = storage_list_dir("/.tests/storage_case", entries, 8);
	ASSERT_EQ_INT(1, count);
	ASSERT_TRUE(find_entry(entries, count, "file.txt", STORAGE_TYPE_FILE));
	return true;
}

static bool test_storage_read_write_remove_file(void) {
	ASSERT_TRUE(test_prepare_storage());
	ASSERT_TRUE(storage_mkdir(".tests/storage_rw"));

	const char* data = "storage-data";
	storage_file_t wf = storage_open("/.tests/storage_rw/data.txt", "w");
	ASSERT_TRUE(wf != NULL);
	ASSERT_EQ_INT((int)strlen(data), (int)storage_write(wf, data, strlen(data)));
	ASSERT_EQ_INT(0, storage_close(wf));

	char buf[32];
	memset(buf, 0, sizeof(buf));
	storage_file_t rf = storage_open(".tests/storage_rw/data.txt", "r");
	ASSERT_TRUE(rf != NULL);
	size_t n = storage_read(rf, buf, sizeof(buf) - 1);
	ASSERT_EQ_INT(0, storage_close(rf));
	ASSERT_EQ_INT((int)strlen(data), (int)n);
	ASSERT_EQ_STR(data, buf);

	ASSERT_TRUE(storage_remove("/.tests/storage_rw/data.txt"));
	ASSERT_FALSE(test_storage_file_exists("/.tests/storage_rw/data.txt"));
	ASSERT_TRUE(storage_remove("/.tests/storage_rw/data.txt"));
	return true;
}

static bool test_storage_invalid_arguments(void) {
	ASSERT_TRUE(storage_init());
	ASSERT_FALSE(storage_mkdir(NULL));
	ASSERT_FALSE(storage_remove(NULL));
	ASSERT_TRUE(storage_open(NULL, "r") == NULL);
	ASSERT_EQ_INT(0, (int)storage_read(NULL, NULL, 0));
	ASSERT_EQ_INT(0, (int)storage_write(NULL, NULL, 0));
	ASSERT_EQ_INT(-1, storage_close(NULL));
	ASSERT_EQ_INT(-1, storage_list_dir("/.tests", NULL, 10));
	return true;
}

void register_storage_sdl_tests(void) {
	test_register("storage_init_and_mount", test_storage_init_and_mount);
	test_register("storage_mkdir_and_list_dir", test_storage_mkdir_and_list_dir);
	test_register("storage_read_write_remove_file",
	              test_storage_read_write_remove_file);
	test_register("storage_invalid_arguments", test_storage_invalid_arguments);
}