mock_nvs.h

#ifndef MOCK_NVS_H
#define MOCK_NVS_H
 
#include "esp_err.h"
#include "nvs.h"
 
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
 
#define MOCK_FLASH_SIZE            (16 * 1024) // 16KB
#define MOCK_NAMESPACE_MAX_SIZE    (32U)
#define MOCK_KEY_MAX_SIZE          (32U)
#define MOCK_HANDLE                (1)
#define MOCK_HANDLE_NAMESPACE_NAME ("storage")
#define MOCK_CONFIG_KEY            ("app_cfg")
 
typedef struct {
    uint8_t memory[MOCK_FLASH_SIZE];              
    size_t size;                                  
    size_t write_size;                            
    char namespace_name[MOCK_NAMESPACE_MAX_SIZE]; 
    char key[MOCK_KEY_MAX_SIZE];                  
    nvs_handle_t handle;                          
} mock_nvs_t;
 
static mock_nvs_t nvs_mock = {0};
 
esp_err_t ram_init (void)
{
    (void) snprintf (nvs_mock.namespace_name, MOCK_NAMESPACE_MAX_SIZE, "%s", MOCK_HANDLE_NAMESPACE_NAME);
    (void) snprintf (nvs_mock.key, MOCK_KEY_MAX_SIZE, "%s", MOCK_CONFIG_KEY);
    nvs_mock.size   = MOCK_FLASH_SIZE;
    nvs_mock.handle = 0;
 
    return ESP_OK;
}
 
esp_err_t ram_open (const char *namespace_name, nvs_open_mode_t mode, nvs_handle_t *handle_ptr)
{
    esp_err_t err = ESP_OK;
 
    (void) mode;
 
    if ((strcmp (namespace_name, nvs_mock.namespace_name) == 0) && (nvs_mock.handle == 0))
    {
        *handle_ptr     = MOCK_HANDLE;
        nvs_mock.handle = MOCK_HANDLE;
    }
    else
    {
        err = ESP_ERR_NO_MEM;
    }
 
    return err;
}
 
esp_err_t ram_read (nvs_handle_t handle, const char *key_ptr, void *dst, size_t *size_ptr)
{
    esp_err_t err = ESP_OK;
    if ((strcmp (key_ptr, nvs_mock.key) == 0) && (handle == nvs_mock.handle) &&
        (*size_ptr <= MOCK_FLASH_SIZE))
    {
        (void) memcpy (dst, nvs_mock.memory, *size_ptr);
    }
    else
    {
        err = ESP_FAIL;
    }
 
    return err;
}
 
esp_err_t ram_write (nvs_handle_t handle, const char *key_ptr, const void *src, size_t size)
{
    esp_err_t err = ESP_OK;
 
    if ((handle == nvs_mock.handle) && (size <= nvs_mock.size))
    {
        (void) memcpy (nvs_mock.memory, src, size);
    }
    else
    {
        err = ESP_FAIL;
    }
 
    return err;
}
 
esp_err_t ram_erase (void)
{
    memset (nvs_mock.memory, 0x00, MOCK_FLASH_SIZE);
 
    return ESP_OK;
}
 
esp_err_t ram_commit (nvs_handle_t handle)
{
    esp_err_t err = ESP_OK;
 
    if (handle != nvs_mock.handle)
    {
        err = ESP_FAIL;
    }
 
    return err;
}
 
void ram_close (nvs_handle_t handle)
{
    if (handle == nvs_mock.handle)
    {
        nvs_mock.handle = 0;
    }
}
 
esp_err_t ram_deinit (void)
{
    nvs_mock.handle = 0;
    return ESP_OK;
}
 
#endif