michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: uart_async_api: run in user mode

Browse source 
Callback registration occurs in new cases which immediately
precede each test.

Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
This commit is contained in:
Andrew Boie 2020-01-13 16:50:03 -08:00 • committed by Anas Nashif
commit cc45266fdc
4 changed files with 112 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

1
tests/drivers/uart/uart_async_api/prj.conf
View file

@ -1,3 +1,4 @@
CONFIG_SERIAL=y
CONFIG_UART_ASYNC_API=y
CONFIG_ZTEST=y
CONFIG_TEST_USERSPACE=y

25
tests/drivers/uart/uart_async_api/src/main.c
View file

@ -15,13 +15,24 @@
void test_main(void)
{
#ifdef CONFIG_USERSPACE
set_permissions();
#endif
ztest_test_suite(uart_async_test,
ztest_unit_test(test_single_read),
ztest_unit_test(test_chained_read),
ztest_unit_test(test_double_buffer),
ztest_unit_test(test_read_abort),
ztest_unit_test(test_chained_write),
ztest_unit_test(test_long_buffers),
ztest_unit_test(test_write_abort));
ztest_unit_test(test_single_read_setup),
ztest_user_unit_test(test_single_read),
ztest_unit_test(test_chained_read_setup),
ztest_user_unit_test(test_chained_read),
ztest_unit_test(test_double_buffer_setup),
ztest_user_unit_test(test_double_buffer),
ztest_unit_test(test_read_abort_setup),
ztest_user_unit_test(test_read_abort),
ztest_unit_test(test_chained_write_setup),
ztest_user_unit_test(test_chained_write),
ztest_unit_test(test_long_buffers_setup),
ztest_user_unit_test(test_long_buffers),
ztest_unit_test(test_write_abort_setup),
ztest_user_unit_test(test_write_abort));
ztest_run_test_suite(uart_async_test);
}

12
tests/drivers/uart/uart_async_api/src/test_uart.h
View file

@ -35,4 +35,16 @@ void test_write_abort(void);
void test_long_buffers(void);
void test_chained_write(void);
void test_single_read_setup(void);
void test_chained_read_setup(void);
void test_double_buffer_setup(void);
void test_read_abort_setup(void);
void test_write_abort_setup(void);
void test_long_buffers_setup(void);
void test_chained_write_setup(void);
#ifdef CONFIG_USERSPACE
void set_permissions(void);
#endif
#endif /* __TEST_UART_H__ */

119
tests/drivers/uart/uart_async_api/src/test_uart_async.c
View file

@ -12,7 +12,16 @@ K_SEM_DEFINE(rx_rdy, 0, 1);
K_SEM_DEFINE(rx_buf_released, 0, 1);
K_SEM_DEFINE(rx_disabled, 0, 1);
#ifdef CONFIG_USERSPACE
void set_permissions(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
k_thread_access_grant(k_current_get(), &tx_done, &tx_aborted,
&rx_rdy, &rx_buf_released, &rx_disabled,
uart_dev);
}
#endif
void test_single_read_callback(struct uart_event *evt, void *user_data)
{
@ -38,21 +47,28 @@ void test_single_read_callback(struct uart_event *evt, void *user_data)
}
ZTEST_BMEM volatile u32_t tx_aborted_count;
void test_single_read_setup(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
uart_callback_set(uart_dev,
test_single_read_callback,
(void *) &tx_aborted_count);
}
void test_single_read(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
volatile u32_t tx_aborted_count = 0;
u8_t rx_buf[10] = {0};
u8_t tx_buf[5] = "test";
zassert_not_equal(memcmp(tx_buf, rx_buf, 5), 0,
"Initial buffer check failed");
uart_callback_set(uart_dev,
test_single_read_callback,
(void *) &tx_aborted_count);
uart_rx_enable(uart_dev, rx_buf, 10, 50);
uart_tx(uart_dev, tx_buf, sizeof(tx_buf), 100);
zassert_equal(k_sem_take(&tx_done, K_MSEC(100)), 0, "TX_DONE timeout");
@ -73,12 +89,12 @@ void test_single_read(void)
zassert_equal(tx_aborted_count, 0, "TX aborted triggered");
}
u8_t chained_read_buf0[10];
u8_t chained_read_buf1[20];
u8_t chained_read_buf2[30];
u8_t buf_num = 1U;
u8_t *read_ptr;
volatile size_t read_len;
ZTEST_BMEM u8_t chained_read_buf0[10];
ZTEST_BMEM u8_t chained_read_buf1[20];
ZTEST_BMEM u8_t chained_read_buf2[30];
ZTEST_DMEM u8_t buf_num = 1U;
ZTEST_BMEM u8_t *read_ptr;
ZTEST_BMEM volatile size_t read_len;
void test_chained_read_callback(struct uart_event *evt, void *user_data)
{
@ -115,13 +131,17 @@ void test_chained_read_callback(struct uart_event *evt, void *user_data)
}
void test_chained_read(void)
void test_chained_read_setup(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
u8_t tx_buf[10];
uart_callback_set(uart_dev, test_chained_read_callback, uart_dev);
}
void test_chained_read(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
u8_t tx_buf[10];
uart_rx_enable(uart_dev, chained_read_buf0, 10, 50);
@ -147,8 +167,8 @@ void test_chained_read(void)
"RX_DISABLED timeout");
}
u8_t double_buffer[2][12];
u8_t *next_buf = double_buffer[1];
ZTEST_BMEM u8_t double_buffer[2][12];
ZTEST_DMEM u8_t *next_buf = double_buffer[1];
void test_double_buffer_callback(struct uart_event *evt, void *user_data)
{
@ -178,13 +198,17 @@ void test_double_buffer_callback(struct uart_event *evt, void *user_data)
}
void test_double_buffer(void)
void test_double_buffer_setup(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
u8_t tx_buf[4];
uart_callback_set(uart_dev, test_double_buffer_callback, uart_dev);
}
void test_double_buffer(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
u8_t tx_buf[4];
zassert_equal(uart_rx_enable(uart_dev,
double_buffer[0],
@ -229,6 +253,13 @@ void test_read_abort_callback(struct uart_event *evt, void *user_data)
}
}
void test_read_abort_setup(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
uart_callback_set(uart_dev, test_read_abort_callback, NULL);
}
void test_read_abort(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
@ -239,8 +270,6 @@ void test_read_abort(void)
memset(rx_buf, 0, sizeof(rx_buf));
memset(tx_buf, 1, sizeof(tx_buf));
uart_callback_set(uart_dev, test_read_abort_callback, NULL);
uart_rx_enable(uart_dev, rx_buf, sizeof(rx_buf), 50);
uart_tx(uart_dev, tx_buf, 5, 100);
@ -262,8 +291,8 @@ void test_read_abort(void)
zassert_not_equal(memcmp(tx_buf, rx_buf, 100), 0, "Buffers equal");
}
volatile size_t sent;
volatile size_t received;
ZTEST_BMEM volatile size_t sent;
ZTEST_BMEM volatile size_t received;
void test_write_abort_callback(struct uart_event *evt, void *user_data)
{
@ -290,6 +319,13 @@ void test_write_abort_callback(struct uart_event *evt, void *user_data)
}
}
void test_write_abort_setup(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
uart_callback_set(uart_dev, test_write_abort_callback, NULL);
}
void test_write_abort(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
@ -300,8 +336,6 @@ void test_write_abort(void)
memset(rx_buf, 0, sizeof(rx_buf));
memset(tx_buf, 1, sizeof(tx_buf));
uart_callback_set(uart_dev, test_write_abort_callback, NULL);
uart_rx_enable(uart_dev, rx_buf, sizeof(rx_buf), 50);
uart_tx(uart_dev, tx_buf, 5, 100);
@ -326,9 +360,9 @@ void test_write_abort(void)
"RX_DISABLED timeout");
}
u8_t chained_write_tx_bufs[2][10] = {"Message 1", "Message 2"};
bool chained_write_next_buf = true;
volatile u8_t tx_sent;
ZTEST_DMEM u8_t chained_write_tx_bufs[2][10] = {"Message 1", "Message 2"};
ZTEST_DMEM bool chained_write_next_buf = true;
ZTEST_BMEM volatile u8_t tx_sent;
void test_chained_write_callback(struct uart_event *evt, void *user_data)
{
@ -362,6 +396,13 @@ void test_chained_write_callback(struct uart_event *evt, void *user_data)
}
}
void test_chained_write_setup(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
uart_callback_set(uart_dev, test_chained_write_callback, uart_dev);
}
void test_chained_write(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
@ -370,8 +411,6 @@ void test_chained_write(void)
memset(rx_buf, 0, sizeof(rx_buf));
uart_callback_set(uart_dev, test_chained_write_callback, uart_dev);
uart_rx_enable(uart_dev, rx_buf, sizeof(rx_buf), 50);
uart_tx(uart_dev, chained_write_tx_bufs[0], 10, 100);
@ -394,11 +433,11 @@ void test_chained_write(void)
"RX_DISABLED timeout");
}
u8_t long_rx_buf[1024];
u8_t long_rx_buf2[1024];
u8_t long_tx_buf[1000];
volatile u8_t evt_num;
size_t long_received[2];
ZTEST_BMEM u8_t long_rx_buf[1024];
ZTEST_BMEM u8_t long_rx_buf2[1024];
ZTEST_BMEM u8_t long_tx_buf[1000];
ZTEST_BMEM volatile u8_t evt_num;
ZTEST_BMEM size_t long_received[2];
void test_long_buffers_callback(struct uart_event *evt, void *user_data)
{
@ -436,16 +475,20 @@ void test_long_buffers_callback(struct uart_event *evt, void *user_data)
}
}
void test_long_buffers_setup(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
uart_callback_set(uart_dev, test_long_buffers_callback, uart_dev);
}
void test_long_buffers(void)
{
struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
memset(long_rx_buf, 0, sizeof(long_rx_buf));
memset(long_tx_buf, 1, sizeof(long_tx_buf));
uart_callback_set(uart_dev, test_long_buffers_callback, uart_dev);
uart_rx_enable(uart_dev, long_rx_buf, sizeof(long_rx_buf), 10);
uart_tx(uart_dev, long_tx_buf, 500, 200);