209 lines
9.8 KiB
C
209 lines
9.8 KiB
C
|
// Host SDK shim: only SDK calls are mocked; the driver lifecycle under test is
|
||
|
|
// inserted verbatim from main/ble_wifi.c by ble-wifi-host.cjs.
|
||
|
|
#include <assert.h>
|
||
|
|
#include <stdbool.h>
|
||
|
|
#include <stdint.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
typedef int esp_err_t;
|
||
|
|
#define ESP_OK 0
|
||
|
|
#define ESP_ERR_NO_MEM 1
|
||
|
|
#define ESP_ERR_INVALID_STATE 2
|
||
|
|
#define ESP_ERR_INVALID_ARG 3
|
||
|
|
#define ESP_ERR_TIMEOUT 4
|
||
|
|
#define ESP_FAIL 5
|
||
|
|
#define BIT0 1
|
||
|
|
#define BIT1 2
|
||
|
|
#define BIT2 4
|
||
|
|
#define pdFALSE 0
|
||
|
|
#define pdMS_TO_TICKS(x) (x)
|
||
|
|
#define MALLOC_CAP_INTERNAL 1
|
||
|
|
#define ESP_EVENT_ANY_ID (-1)
|
||
|
|
#define WIFI_EVENT 1
|
||
|
|
#define IP_EVENT 2
|
||
|
|
#define IP_EVENT_STA_GOT_IP 1
|
||
|
|
#define WIFI_EVENT_STA_DISCONNECTED 2
|
||
|
|
#define WIFI_EVENT_STA_STOP 3
|
||
|
|
#define WIFI_STORAGE_RAM 1
|
||
|
|
#define WIFI_MODE_STA 1
|
||
|
|
#define WIFI_IF_STA 0
|
||
|
|
#define WIFI_AUTH_WPA2_PSK 3
|
||
|
|
#define WIFI_ALL_CHANNEL_SCAN 1
|
||
|
|
#define WIFI_CONNECT_AP_BY_SIGNAL 1
|
||
|
|
typedef int esp_event_base_t;
|
||
|
|
typedef int *esp_event_handler_instance_t;
|
||
|
|
typedef unsigned EventBits_t;
|
||
|
|
typedef EventBits_t *EventGroupHandle_t;
|
||
|
|
typedef struct { int placeholder; } esp_netif_t;
|
||
|
|
typedef struct { int placeholder; } esp_netif_config_t;
|
||
|
|
#define ESP_NETIF_DEFAULT_WIFI_STA() ((esp_netif_config_t){0})
|
||
|
|
typedef struct { unsigned reason; } wifi_event_sta_disconnected_t;
|
||
|
|
typedef struct {
|
||
|
|
int static_rx_buf_num, dynamic_rx_buf_num, static_tx_buf_num, cache_tx_buf_num;
|
||
|
|
int ampdu_rx_enable, ampdu_tx_enable, amsdu_tx_enable;
|
||
|
|
} wifi_init_config_t;
|
||
|
|
#define WIFI_INIT_CONFIG_DEFAULT() ((wifi_init_config_t){16,32,16,32,1,1,0})
|
||
|
|
typedef struct { struct {
|
||
|
|
char ssid[32], password[64];
|
||
|
|
struct { int authmode; } threshold;
|
||
|
|
int scan_method, sort_method;
|
||
|
|
} sta; } wifi_config_t;
|
||
|
|
static void mock_log(const char *tag, const char *format, ...) {(void)tag; (void)format;}
|
||
|
|
#define ESP_LOGI(...) mock_log(__VA_ARGS__)
|
||
|
|
#define ESP_LOGW(...) mock_log(__VA_ARGS__)
|
||
|
|
#define ESP_LOGE(...) mock_log(__VA_ARGS__)
|
||
|
|
static const char *esp_err_to_name(esp_err_t err) {(void)err; return "mock";}
|
||
|
|
static unsigned heap_caps_get_free_size(int cap) {(void)cap; return 50000;}
|
||
|
|
static unsigned heap_caps_get_largest_free_block(int cap) {(void)cap; return 30000;}
|
||
|
|
|
||
|
|
enum point { NONE, GROUP, NEW_NETIF, ATTACH, DEFAULT_HANDLERS, DRIVER,
|
||
|
|
WIFI_HANDLER, IP_HANDLER, STORAGE, MODE, CONFIG, START, CONNECT, STOP, POINTS };
|
||
|
|
static int calls[POINTS], fail_point, failures, destroys, foreign;
|
||
|
|
static bool should_connect, emit_disconnect, stop_ack;
|
||
|
|
static EventBits_t bits;
|
||
|
|
static esp_netif_t mock_station, other_station;
|
||
|
|
static int handler_handles[2];
|
||
|
|
static wifi_config_t last_config;
|
||
|
|
static void (*callback)(void *, esp_event_base_t, int32_t, void *);
|
||
|
|
static bool fail(enum point point) {
|
||
|
|
calls[point]++;
|
||
|
|
if (fail_point == (int)point && failures) {failures--; return true;}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
static EventGroupHandle_t xEventGroupCreate(void) {return fail(GROUP) ? NULL : &bits;}
|
||
|
|
static EventBits_t xEventGroupGetBits(EventGroupHandle_t e) {assert(e); return *e;}
|
||
|
|
static EventBits_t xEventGroupSetBits(EventGroupHandle_t e, EventBits_t b) {return *e |= b;}
|
||
|
|
static EventBits_t xEventGroupClearBits(EventGroupHandle_t e, EventBits_t b) {EventBits_t old=*e; *e &= ~b; return old;}
|
||
|
|
static EventBits_t xEventGroupWaitBits(EventGroupHandle_t e, EventBits_t b, int clear, int all, int ticks) {
|
||
|
|
(void)b; (void)clear; (void)all; (void)ticks; return *e;
|
||
|
|
}
|
||
|
|
static void vTaskDelay(int ticks) {(void)ticks;}
|
||
|
|
static esp_netif_t *esp_netif_get_handle_from_ifkey(const char *key) {
|
||
|
|
assert(!strcmp(key, "WIFI_STA")); return foreign ? &other_station : NULL;
|
||
|
|
}
|
||
|
|
static esp_netif_t *esp_netif_new(const esp_netif_config_t *c) {
|
||
|
|
(void)c; return fail(NEW_NETIF) ? NULL : &mock_station;
|
||
|
|
}
|
||
|
|
static esp_err_t esp_netif_attach_wifi_station(esp_netif_t *n) {assert(n); return fail(ATTACH) ? ESP_FAIL : ESP_OK;}
|
||
|
|
static esp_err_t esp_wifi_set_default_wifi_sta_handlers(void) {return fail(DEFAULT_HANDLERS) ? ESP_FAIL : ESP_OK;}
|
||
|
|
static void esp_netif_destroy_default_wifi(esp_netif_t *n) {assert(n == &mock_station); destroys++;}
|
||
|
|
static esp_err_t esp_wifi_init(const wifi_init_config_t *c) {
|
||
|
|
assert(c->static_rx_buf_num == 4 && c->static_tx_buf_num == 4);
|
||
|
|
assert(c->dynamic_rx_buf_num >= c->static_rx_buf_num && c->cache_tx_buf_num == 4);
|
||
|
|
assert(!c->ampdu_rx_enable && !c->ampdu_tx_enable && !c->amsdu_tx_enable);
|
||
|
|
return fail(DRIVER) ? ESP_ERR_NO_MEM : ESP_OK;
|
||
|
|
}
|
||
|
|
static esp_err_t esp_event_handler_instance_register(esp_event_base_t base, int id,
|
||
|
|
void (*cb)(void *, esp_event_base_t, int32_t, void *), void *arg, esp_event_handler_instance_t *instance) {
|
||
|
|
(void)id; (void)arg;
|
||
|
|
if (fail(base == WIFI_EVENT ? WIFI_HANDLER : IP_HANDLER)) return ESP_ERR_NO_MEM;
|
||
|
|
callback = cb; *instance = &handler_handles[base == WIFI_EVENT ? 0 : 1]; return ESP_OK;
|
||
|
|
}
|
||
|
|
static esp_err_t esp_wifi_set_storage(int storage) {assert(storage == WIFI_STORAGE_RAM); return fail(STORAGE) ? ESP_FAIL : ESP_OK;}
|
||
|
|
static esp_err_t esp_wifi_set_mode(int mode) {assert(mode == WIFI_MODE_STA); return fail(MODE) ? ESP_FAIL : ESP_OK;}
|
||
|
|
static esp_err_t esp_wifi_set_config(int iface, const wifi_config_t *c) {
|
||
|
|
assert(iface == WIFI_IF_STA); last_config = *c; return fail(CONFIG) ? ESP_FAIL : ESP_OK;
|
||
|
|
}
|
||
|
|
static esp_err_t esp_wifi_start(void) {return fail(START) ? ESP_ERR_NO_MEM : ESP_OK;}
|
||
|
|
static esp_err_t esp_wifi_connect(void) {
|
||
|
|
if (fail(CONNECT)) return ESP_FAIL;
|
||
|
|
if (should_connect) callback(NULL, IP_EVENT, IP_EVENT_STA_GOT_IP, NULL);
|
||
|
|
else if (emit_disconnect) {wifi_event_sta_disconnected_t e = {201}; callback(NULL, WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &e);}
|
||
|
|
return ESP_OK;
|
||
|
|
}
|
||
|
|
static esp_err_t esp_wifi_stop(void) {
|
||
|
|
if (fail(STOP)) return ESP_FAIL;
|
||
|
|
if (stop_ack) callback(NULL, WIFI_EVENT, WIFI_EVENT_STA_STOP, NULL);
|
||
|
|
return ESP_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* PRODUCTION_SOURCE */
|
||
|
|
|
||
|
|
static void reset(void) {
|
||
|
|
station=NULL; events=NULL; wifi_handler=NULL; ip_handler=NULL;
|
||
|
|
driver_ready=false; prepared=false; started=false; stopping=false;
|
||
|
|
memset(calls,0,sizeof(calls)); memset(&last_config,0,sizeof(last_config));
|
||
|
|
fail_point=NONE; failures=0; destroys=0; foreign=0; bits=0;
|
||
|
|
should_connect=true; emit_disconnect=false; stop_ack=true; callback=NULL;
|
||
|
|
}
|
||
|
|
int main(void) {
|
||
|
|
unsigned tests=0;
|
||
|
|
reset();
|
||
|
|
assert(!ble_wifi_connected());
|
||
|
|
assert(ble_wifi_prepare()==ESP_OK && ble_wifi_prepare()==ESP_OK);
|
||
|
|
assert(calls[DRIVER]==1 && calls[NEW_NETIF]==1 && calls[GROUP]==1);
|
||
|
|
assert(calls[START]==0 && calls[CONNECT]==0); tests++;
|
||
|
|
|
||
|
|
// Every initialization failure is recoverable, without duplicate owners.
|
||
|
|
for (enum point p=GROUP; p<=MODE; ++p) {
|
||
|
|
reset(); fail_point=p; failures=1;
|
||
|
|
assert(ble_wifi_prepare()!=ESP_OK);
|
||
|
|
assert(ble_wifi_prepare()==ESP_OK);
|
||
|
|
assert(ble_wifi_prepare()==ESP_OK);
|
||
|
|
assert(calls[NEW_NETIF] <= ((p==NEW_NETIF || p==ATTACH || p==DEFAULT_HANDLERS) ? 2 : 1));
|
||
|
|
assert(calls[GROUP] == (p==GROUP ? 2 : 1));
|
||
|
|
assert(calls[DRIVER] == (p==DRIVER ? 2 : 1));
|
||
|
|
assert(destroys == (p==ATTACH || p==DEFAULT_HANDLERS ? 1 : 0));
|
||
|
|
tests++;
|
||
|
|
}
|
||
|
|
reset(); fail_point=DRIVER; failures=10;
|
||
|
|
for (int i=0; i<10; ++i) assert(ble_wifi_prepare()==ESP_ERR_NO_MEM);
|
||
|
|
assert(ble_wifi_prepare()==ESP_OK);
|
||
|
|
assert(calls[NEW_NETIF]==1 && calls[GROUP]==1 && calls[DEFAULT_HANDLERS]==1); tests++;
|
||
|
|
|
||
|
|
reset(); foreign=1;
|
||
|
|
assert(ble_wifi_prepare()==ESP_ERR_INVALID_STATE);
|
||
|
|
assert(calls[NEW_NETIF]==0 && destroys==0); tests++;
|
||
|
|
|
||
|
|
reset(); assert(ble_wifi_connect("test-network","test-password")==ESP_OK);
|
||
|
|
assert(ble_wifi_connected());
|
||
|
|
assert(!strcmp(last_config.sta.ssid,"test-network"));
|
||
|
|
assert(!strcmp(last_config.sta.password,"test-password"));
|
||
|
|
assert(last_config.sta.threshold.authmode==WIFI_AUTH_WPA2_PSK);
|
||
|
|
assert(ble_wifi_connect("new-network","new-password")==ESP_OK);
|
||
|
|
assert(calls[DRIVER]==1 && calls[NEW_NETIF]==1 && calls[STOP]==1);
|
||
|
|
assert(!strcmp(last_config.sta.ssid,"new-network")); tests++;
|
||
|
|
|
||
|
|
for (enum point p=CONFIG; p<=CONNECT; ++p) {
|
||
|
|
reset(); fail_point=p; failures=3;
|
||
|
|
while(failures) assert(ble_wifi_connect("test-network","test-password")!=ESP_OK);
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_OK);
|
||
|
|
assert(calls[DRIVER]==1 && calls[NEW_NETIF]==1 && calls[GROUP]==1); tests++;
|
||
|
|
}
|
||
|
|
for (int disconnect=0; disconnect<2; ++disconnect) {
|
||
|
|
reset(); should_connect=false; emit_disconnect=disconnect;
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_ERR_TIMEOUT);
|
||
|
|
assert(!ble_wifi_connected() && calls[START]==3 && calls[STOP]==3);
|
||
|
|
should_connect=true;
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_OK);
|
||
|
|
assert(calls[NEW_NETIF]==1 && calls[DRIVER]==1); tests++;
|
||
|
|
}
|
||
|
|
reset(); assert(ble_wifi_connect("test-network","test-password")==ESP_OK);
|
||
|
|
wifi_event_sta_disconnected_t e={201};
|
||
|
|
callback(NULL,WIFI_EVENT,WIFI_EVENT_STA_DISCONNECTED,&e);
|
||
|
|
assert(!ble_wifi_connected()); tests++;
|
||
|
|
|
||
|
|
reset(); assert(ble_wifi_connect("test-network","test-password")==ESP_OK);
|
||
|
|
fail_point=STOP; failures=1;
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_FAIL);
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_OK);
|
||
|
|
assert(calls[DRIVER]==1); tests++;
|
||
|
|
|
||
|
|
reset(); assert(ble_wifi_connect("test-network","test-password")==ESP_OK);
|
||
|
|
stop_ack=false;
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_ERR_TIMEOUT);
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_ERR_TIMEOUT);
|
||
|
|
assert(calls[STOP]==1);
|
||
|
|
assert(calls[CONNECT]==1);
|
||
|
|
callback(NULL,WIFI_EVENT,WIFI_EVENT_STA_STOP,NULL); stop_ack=true;
|
||
|
|
assert(ble_wifi_connect("test-network","test-password")==ESP_OK); tests++;
|
||
|
|
|
||
|
|
reset(); assert(ble_wifi_connect(NULL,"password")==ESP_ERR_INVALID_ARG);
|
||
|
|
assert(ble_wifi_connect("","password")==ESP_ERR_INVALID_ARG);
|
||
|
|
assert(ble_wifi_connect("network",NULL)==ESP_ERR_INVALID_ARG);
|
||
|
|
assert(calls[NEW_NETIF]==0); tests++;
|
||
|
|
printf("PASS: %u Wi-Fi lifecycle/fault-injection cases (production C)\n",tests);
|
||
|
|
return 0;
|
||
|
|
}
|