| /* |
| * Copyright (c) 2023 Nordic Semiconductor ASA |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <zephyr/ztest.h> |
| #include <zephyr/kernel.h> |
| #include <string.h> |
| |
| #include <zephyr/modem/cmux.h> |
| #include <modem_backend_mock.h> |
| |
| /* CMUX state flags */ |
| #define EVENT_CMUX_CONNECTED BIT(0) |
| #define EVENT_CMUX_DLCI1_OPEN BIT(1) |
| #define EVENT_CMUX_DLCI2_OPEN BIT(2) |
| #define EVENT_CMUX_DLCI1_CLOSED BIT(3) |
| #define EVENT_CMUX_DLCI2_CLOSED BIT(4) |
| #define EVENT_CMUX_DISCONNECTED BIT(5) |
| #define EVENT_CMUX_DLCI1_RX_DATA BIT(6) |
| #define EVENT_CMUX_DLCI2_RX_DATA BIT(7) |
| |
| /* CMUX DTE variables */ |
| static struct modem_cmux cmux_dte; |
| static uint8_t cmux_receive_buf[127]; |
| static uint8_t cmux_transmit_buf[149]; |
| static struct modem_cmux_dlci dlci1; |
| static struct modem_cmux_dlci dlci2; |
| static struct modem_pipe *dlci1_pipe; |
| static struct modem_pipe *dlci2_pipe; |
| |
| /* CMUX DCE variables */ |
| static struct modem_cmux cmux_dce; |
| static uint8_t cmux_receive_buf_dce[127]; |
| static uint8_t cmux_transmit_buf_dce[149]; |
| static struct modem_cmux_dlci dlci1_dce; |
| static struct modem_cmux_dlci dlci2_dce; |
| static struct modem_pipe *dlci1_pipe_dce; |
| static struct modem_pipe *dlci2_pipe_dce; |
| |
| /* DTE & DCE Event */ |
| static struct k_event cmux_event_dte; |
| static struct k_event cmux_event_dce; |
| |
| /* Backend MOCK */ |
| static struct modem_backend_mock bus_mock_dte; |
| static struct modem_backend_mock bus_mock_dce; |
| static uint8_t bus_mock_rx_buf[2048]; |
| static uint8_t bus_mock_tx_buf[2048]; |
| static uint8_t bus_mock_rx_buf_dce[2048]; |
| static uint8_t bus_mock_tx_buf_dce[2048]; |
| static struct modem_pipe *bus_mock_pipe; |
| static struct modem_pipe *bus_mock_pipe_dce; |
| |
| static uint8_t dlci1_receive_buf[127]; |
| static uint8_t dlci2_receive_buf[127]; |
| static uint8_t dlci1_receive_buf_dce[127]; |
| static uint8_t dlci2_receive_buf_dce[127]; |
| |
| static uint8_t buffer1[2048]; |
| static uint8_t buffer2[2048]; |
| |
| static void test_dlci1_pipe_cb(struct modem_pipe *pipe, enum modem_pipe_event event, |
| void *user_data) |
| { |
| switch (event) { |
| case MODEM_PIPE_EVENT_OPENED: |
| k_event_post(&cmux_event_dte, EVENT_CMUX_DLCI1_OPEN); |
| break; |
| |
| case MODEM_PIPE_EVENT_CLOSED: |
| k_event_post(&cmux_event_dte, EVENT_CMUX_DLCI1_CLOSED); |
| break; |
| |
| case MODEM_PIPE_EVENT_RECEIVE_READY: |
| k_event_post(&cmux_event_dte, EVENT_CMUX_DLCI1_RX_DATA); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| static void test_dlci2_pipe_cb(struct modem_pipe *pipe, enum modem_pipe_event event, |
| void *user_data) |
| { |
| switch (event) { |
| case MODEM_PIPE_EVENT_OPENED: |
| k_event_post(&cmux_event_dte, EVENT_CMUX_DLCI2_OPEN); |
| break; |
| |
| case MODEM_PIPE_EVENT_CLOSED: |
| k_event_post(&cmux_event_dte, EVENT_CMUX_DLCI2_CLOSED); |
| break; |
| case MODEM_PIPE_EVENT_RECEIVE_READY: |
| k_event_post(&cmux_event_dte, EVENT_CMUX_DLCI2_RX_DATA); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| static void test_dlci1_pipe_cb_dce(struct modem_pipe *pipe, enum modem_pipe_event event, |
| void *user_data) |
| { |
| switch (event) { |
| case MODEM_PIPE_EVENT_OPENED: |
| k_event_post(&cmux_event_dce, EVENT_CMUX_DLCI1_OPEN); |
| break; |
| |
| case MODEM_PIPE_EVENT_CLOSED: |
| k_event_post(&cmux_event_dce, EVENT_CMUX_DLCI1_CLOSED); |
| break; |
| |
| case MODEM_PIPE_EVENT_RECEIVE_READY: |
| k_event_post(&cmux_event_dce, EVENT_CMUX_DLCI1_RX_DATA); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| static void test_dlci2_pipe_cb_dce(struct modem_pipe *pipe, enum modem_pipe_event event, |
| void *user_data) |
| { |
| switch (event) { |
| case MODEM_PIPE_EVENT_OPENED: |
| k_event_post(&cmux_event_dce, EVENT_CMUX_DLCI2_OPEN); |
| break; |
| |
| case MODEM_PIPE_EVENT_CLOSED: |
| k_event_post(&cmux_event_dce, EVENT_CMUX_DLCI2_CLOSED); |
| break; |
| case MODEM_PIPE_EVENT_RECEIVE_READY: |
| k_event_post(&cmux_event_dce, EVENT_CMUX_DLCI2_RX_DATA); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| /*************************************************************************************************/ |
| /* DLCI2 AT CMUX frames */ |
| /*************************************************************************************************/ |
| static uint8_t cmux_frame_data_dlci2_at_cgdcont[] = { |
| 0x41, 0x54, 0x2B, 0x43, 0x47, 0x44, 0x43, 0x4F, 0x4E, 0x54, 0x3D, |
| 0x31, 0x2C, 0x22, 0x49, 0x50, 0x22, 0x2C, 0x22, 0x74, 0x72, 0x61, |
| 0x63, 0x6B, 0x75, 0x6E, 0x69, 0x74, 0x2E, 0x6D, 0x32, 0x6D, 0x22}; |
| |
| static uint8_t cmux_frame_data_dlci2_at_newline[] = {0x0D, 0x0A}; |
| |
| /*************************************************************************************************/ |
| /* DLCI1 AT CMUX frames */ |
| /*************************************************************************************************/ |
| static uint8_t cmux_frame_data_dlci1_at_at[] = {0x41, 0x54}; |
| |
| static uint8_t cmux_frame_data_dlci1_at_newline[] = {0x0D, 0x0A}; |
| |
| /*************************************************************************************************/ |
| /* DLCI2 PPP CMUX frames */ |
| /*************************************************************************************************/ |
| static uint8_t cmux_frame_data_dlci2_ppp_52[] = { |
| 0x7E, 0xFF, 0x7D, 0x23, 0xC0, 0x21, 0x7D, 0x21, 0x7D, 0x20, 0x7D, 0x20, 0x7D, |
| 0x38, 0x7D, 0x22, 0x7D, 0x26, 0x7D, 0x20, 0x7D, 0x20, 0x7D, 0x20, 0x7D, 0x20, |
| 0x7D, 0x23, 0x7D, 0x24, 0xC0, 0x23, 0x7D, 0x25, 0x7D, 0x26, 0x53, 0x96, 0x7D, |
| 0x38, 0xAA, 0x7D, 0x27, 0x7D, 0x22, 0x7D, 0x28, 0x7D, 0x22, 0xD5, 0xA8, 0x7E}; |
| |
| static uint8_t cmux_frame_data_dlci2_ppp_18[] = {0x7E, 0xFF, 0x7D, 0x23, 0xC0, 0x21, |
| 0x7D, 0x22, 0x7D, 0x21, 0x7D, 0x20, |
| 0x7D, 0x24, 0x7D, 0x3C, 0x90, 0x7E}; |
| |
| static void test_cmux_ctrl_cb(struct modem_cmux *cmux, enum modem_cmux_event event, void *user_data) |
| { |
| if (event == MODEM_CMUX_EVENT_CONNECTED) { |
| k_event_post(&cmux_event_dte, EVENT_CMUX_CONNECTED); |
| return; |
| } |
| |
| if (event == MODEM_CMUX_EVENT_DISCONNECTED) { |
| k_event_post(&cmux_event_dte, EVENT_CMUX_DISCONNECTED); |
| return; |
| } |
| } |
| |
| static void test_cmux_ctrl_cb_dce(struct modem_cmux *cmux, enum modem_cmux_event event, |
| void *user_data) |
| { |
| if (event == MODEM_CMUX_EVENT_CONNECTED) { |
| k_event_post(&cmux_event_dce, EVENT_CMUX_CONNECTED); |
| return; |
| } |
| |
| if (event == MODEM_CMUX_EVENT_DISCONNECTED) { |
| k_event_post(&cmux_event_dce, EVENT_CMUX_DISCONNECTED); |
| return; |
| } |
| } |
| |
| static void cmux_dte_init(void) |
| { |
| struct modem_cmux_dlci_config dlci1_config = { |
| .dlci_address = 1, |
| .receive_buf = dlci1_receive_buf, |
| .receive_buf_size = sizeof(dlci1_receive_buf), |
| }; |
| |
| struct modem_cmux_dlci_config dlci2_config = { |
| .dlci_address = 2, |
| .receive_buf = dlci2_receive_buf, |
| .receive_buf_size = sizeof(dlci2_receive_buf), |
| }; |
| |
| struct modem_cmux_config cmux_config = { |
| .callback = test_cmux_ctrl_cb, |
| .user_data = NULL, |
| .receive_buf = cmux_receive_buf, |
| .receive_buf_size = sizeof(cmux_receive_buf), |
| .transmit_buf = cmux_transmit_buf, |
| .transmit_buf_size = ARRAY_SIZE(cmux_transmit_buf), |
| }; |
| |
| const struct modem_backend_mock_config bus_mock_config = { |
| .rx_buf = bus_mock_rx_buf, |
| .rx_buf_size = sizeof(bus_mock_rx_buf), |
| .tx_buf = bus_mock_tx_buf, |
| .tx_buf_size = sizeof(bus_mock_tx_buf), |
| .limit = 32, |
| }; |
| |
| modem_cmux_init(&cmux_dte, &cmux_config); |
| dlci1_pipe = modem_cmux_dlci_init(&cmux_dte, &dlci1, &dlci1_config); |
| dlci2_pipe = modem_cmux_dlci_init(&cmux_dte, &dlci2, &dlci2_config); |
| /* Init Backend DTE */ |
| bus_mock_pipe = modem_backend_mock_init(&bus_mock_dte, &bus_mock_config); |
| __ASSERT_NO_MSG(modem_pipe_open(bus_mock_pipe) == 0); |
| __ASSERT_NO_MSG(modem_cmux_attach(&cmux_dte, bus_mock_pipe) == 0); |
| modem_pipe_attach(dlci1_pipe, test_dlci1_pipe_cb, NULL); |
| modem_pipe_attach(dlci2_pipe, test_dlci2_pipe_cb, NULL); |
| } |
| |
| static void cmux_dce_init(void) |
| { |
| struct modem_cmux_dlci_config dlci1_config = { |
| .dlci_address = 1, |
| .receive_buf = dlci1_receive_buf_dce, |
| .receive_buf_size = sizeof(dlci1_receive_buf_dce), |
| }; |
| |
| struct modem_cmux_dlci_config dlci2_config = { |
| .dlci_address = 2, |
| .receive_buf = dlci2_receive_buf_dce, |
| .receive_buf_size = sizeof(dlci2_receive_buf_dce), |
| }; |
| |
| struct modem_cmux_config cmux_config_dce = { |
| .callback = test_cmux_ctrl_cb_dce, |
| .user_data = NULL, |
| .receive_buf = cmux_receive_buf_dce, |
| .receive_buf_size = sizeof(cmux_receive_buf_dce), |
| .transmit_buf = cmux_transmit_buf_dce, |
| .transmit_buf_size = ARRAY_SIZE(cmux_transmit_buf_dce), |
| }; |
| |
| const struct modem_backend_mock_config bus_mock_config = { |
| .rx_buf = bus_mock_rx_buf_dce, |
| .rx_buf_size = sizeof(bus_mock_rx_buf_dce), |
| .tx_buf = bus_mock_tx_buf_dce, |
| .tx_buf_size = sizeof(bus_mock_tx_buf_dce), |
| .limit = 32, |
| }; |
| |
| modem_cmux_init(&cmux_dce, &cmux_config_dce); |
| dlci1_pipe_dce = modem_cmux_dlci_init(&cmux_dce, &dlci1_dce, &dlci1_config); |
| dlci2_pipe_dce = modem_cmux_dlci_init(&cmux_dce, &dlci2_dce, &dlci2_config); |
| /* Init Backend DCE */ |
| bus_mock_pipe_dce = modem_backend_mock_init(&bus_mock_dce, &bus_mock_config); |
| __ASSERT_NO_MSG(modem_pipe_open(bus_mock_pipe_dce) == 0); |
| __ASSERT_NO_MSG(modem_cmux_attach(&cmux_dce, bus_mock_pipe_dce) == 0); |
| modem_pipe_attach(dlci1_pipe_dce, test_dlci1_pipe_cb_dce, NULL); |
| modem_pipe_attach(dlci2_pipe_dce, test_dlci2_pipe_cb_dce, NULL); |
| } |
| |
| static void *test_setup(void) |
| { |
| uint32_t events; |
| |
| /* Init Event mask's */ |
| k_event_init(&cmux_event_dte); |
| k_event_init(&cmux_event_dce); |
| |
| /* Init CMUX, Pipe and Backend instances */ |
| cmux_dte_init(); |
| cmux_dce_init(); |
| |
| /* Create MOCK bridge */ |
| modem_backend_mock_bridge(&bus_mock_dte, &bus_mock_dce); |
| |
| /* Connect CMUX by DTE */ |
| __ASSERT_NO_MSG(modem_cmux_connect_async(&cmux_dte) == 0); |
| events = k_event_wait(&cmux_event_dte, EVENT_CMUX_CONNECTED, false, K_MSEC(100)); |
| __ASSERT_NO_MSG((events & EVENT_CMUX_CONNECTED)); |
| events = k_event_wait(&cmux_event_dce, EVENT_CMUX_CONNECTED, false, K_MSEC(100)); |
| __ASSERT_NO_MSG((events & EVENT_CMUX_CONNECTED)); |
| |
| /* Open DLCI channels init by DTE */ |
| __ASSERT_NO_MSG(modem_pipe_open_async(dlci1_pipe) == 0); |
| events = k_event_wait(&cmux_event_dte, EVENT_CMUX_DLCI1_OPEN, false, K_MSEC(100)); |
| __ASSERT_NO_MSG((events & EVENT_CMUX_DLCI1_OPEN)); |
| events = k_event_wait(&cmux_event_dce, EVENT_CMUX_DLCI1_OPEN, false, K_MSEC(100)); |
| __ASSERT_NO_MSG((events & EVENT_CMUX_DLCI1_OPEN)); |
| |
| __ASSERT_NO_MSG(modem_pipe_open_async(dlci2_pipe) == 0); |
| events = k_event_wait(&cmux_event_dte, EVENT_CMUX_DLCI2_OPEN, false, K_MSEC(100)); |
| __ASSERT_NO_MSG((events & EVENT_CMUX_DLCI2_OPEN)); |
| events = k_event_wait(&cmux_event_dce, EVENT_CMUX_DLCI2_OPEN, false, K_MSEC(100)); |
| __ASSERT_NO_MSG((events & EVENT_CMUX_DLCI2_OPEN)); |
| |
| return NULL; |
| } |
| |
| static void test_before(void *f) |
| { |
| /* Reset events */ |
| k_event_clear(&cmux_event_dte, UINT32_MAX); |
| k_event_clear(&cmux_event_dce, UINT32_MAX); |
| |
| /* Reset mock pipes */ |
| modem_backend_mock_reset(&bus_mock_dte); |
| modem_backend_mock_reset(&bus_mock_dce); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_dce_receive_dlci2_at) |
| { |
| int ret; |
| uint32_t events; |
| |
| modem_pipe_transmit(dlci2_pipe, cmux_frame_data_dlci2_at_cgdcont, |
| sizeof(cmux_frame_data_dlci2_at_cgdcont)); |
| |
| modem_pipe_transmit(dlci2_pipe, cmux_frame_data_dlci2_at_newline, |
| sizeof(cmux_frame_data_dlci2_at_newline)); |
| |
| k_msleep(100); |
| |
| events = k_event_wait(&cmux_event_dce, EVENT_CMUX_DLCI2_RX_DATA, false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI2_RX_DATA), "DLCI2 dce not rx data"); |
| |
| ret = modem_pipe_receive(dlci2_pipe_dce, buffer2, sizeof(buffer2)); |
| zassert_true(ret == (sizeof(cmux_frame_data_dlci2_at_cgdcont) + |
| sizeof(cmux_frame_data_dlci2_at_newline)), |
| "Incorrect number of bytes received"); |
| |
| zassert_true(memcmp(buffer2, cmux_frame_data_dlci2_at_cgdcont, |
| sizeof(cmux_frame_data_dlci2_at_cgdcont)) == 0, |
| "Incorrect data received"); |
| |
| zassert_true(memcmp(&buffer2[sizeof(cmux_frame_data_dlci2_at_cgdcont)], |
| cmux_frame_data_dlci2_at_newline, |
| sizeof(cmux_frame_data_dlci2_at_newline)) == 0, |
| "Incorrect data received"); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_dce_receive_dlci1_at) |
| { |
| int ret; |
| uint32_t events; |
| |
| modem_pipe_transmit(dlci1_pipe, cmux_frame_data_dlci1_at_at, |
| sizeof(cmux_frame_data_dlci1_at_at)); |
| modem_pipe_transmit(dlci1_pipe, cmux_frame_data_dlci1_at_newline, |
| sizeof(cmux_frame_data_dlci1_at_newline)); |
| |
| k_msleep(100); |
| |
| events = k_event_wait(&cmux_event_dce, EVENT_CMUX_DLCI1_RX_DATA, false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI1_RX_DATA), "DLCI1 dce not rx data"); |
| |
| ret = modem_pipe_receive(dlci1_pipe_dce, buffer1, sizeof(buffer1)); |
| zassert_true(ret == (sizeof(cmux_frame_data_dlci1_at_at) + |
| sizeof(cmux_frame_data_dlci1_at_newline)), |
| "Incorrect number of bytes received"); |
| |
| zassert_true(memcmp(buffer1, cmux_frame_data_dlci1_at_at, |
| sizeof(cmux_frame_data_dlci1_at_at)) == 0, |
| "Incorrect data received"); |
| |
| zassert_true(memcmp(&buffer1[sizeof(cmux_frame_data_dlci1_at_at)], |
| cmux_frame_data_dlci1_at_newline, |
| sizeof(cmux_frame_data_dlci1_at_newline)) == 0, |
| "Incorrect data received"); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_dce_receive_dlci2_ppp) |
| { |
| int ret; |
| |
| uint32_t events; |
| |
| modem_pipe_transmit(dlci2_pipe, cmux_frame_data_dlci2_ppp_52, |
| sizeof(cmux_frame_data_dlci2_ppp_52)); |
| modem_pipe_transmit(dlci2_pipe, cmux_frame_data_dlci2_ppp_18, |
| sizeof(cmux_frame_data_dlci2_ppp_18)); |
| |
| k_msleep(100); |
| |
| events = k_event_wait(&cmux_event_dce, EVENT_CMUX_DLCI2_RX_DATA, false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI2_RX_DATA), "DLCI2 dce not rx data"); |
| |
| ret = modem_pipe_receive(dlci2_pipe_dce, buffer2, sizeof(buffer2)); |
| zassert_true(ret == (sizeof(cmux_frame_data_dlci2_ppp_52) + |
| sizeof(cmux_frame_data_dlci2_ppp_18)), |
| "Incorrect number of bytes received"); |
| |
| zassert_true(memcmp(buffer2, cmux_frame_data_dlci2_ppp_52, |
| sizeof(cmux_frame_data_dlci2_ppp_52)) == 0, |
| "Incorrect data received"); |
| |
| zassert_true(memcmp(&buffer2[sizeof(cmux_frame_data_dlci2_ppp_52)], |
| cmux_frame_data_dlci2_ppp_18, |
| sizeof(cmux_frame_data_dlci2_ppp_18)) == 0, |
| "Incorrect data received"); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_dce_transmit_dlci2_ppp) |
| { |
| int ret; |
| uint32_t events; |
| |
| ret = modem_pipe_transmit(dlci2_pipe_dce, cmux_frame_data_dlci2_ppp_52, |
| sizeof(cmux_frame_data_dlci2_ppp_52)); |
| |
| zassert_true(ret == sizeof(cmux_frame_data_dlci2_ppp_52), "Failed to send DLCI2 PPP 52 %d", |
| ret); |
| ret = modem_pipe_transmit(dlci2_pipe_dce, cmux_frame_data_dlci2_ppp_18, |
| sizeof(cmux_frame_data_dlci2_ppp_18)); |
| |
| zassert_true(ret == sizeof(cmux_frame_data_dlci2_ppp_18), "Failed to send DLCI2 PPP 18"); |
| |
| k_msleep(100); |
| |
| events = k_event_wait(&cmux_event_dte, EVENT_CMUX_DLCI2_RX_DATA, false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI2_RX_DATA), "DLCI2 dce not rx data"); |
| |
| ret = modem_pipe_receive(dlci2_pipe, buffer2, sizeof(buffer2)); |
| zassert_true(ret == (sizeof(cmux_frame_data_dlci2_ppp_52) + |
| sizeof(cmux_frame_data_dlci2_ppp_18)), |
| "Incorrect number of bytes received"); |
| |
| zassert_true(memcmp(buffer2, cmux_frame_data_dlci2_ppp_52, |
| sizeof(cmux_frame_data_dlci2_ppp_52)) == 0, |
| "Incorrect data received"); |
| |
| zassert_true(memcmp(&buffer2[sizeof(cmux_frame_data_dlci2_ppp_52)], |
| cmux_frame_data_dlci2_ppp_18, |
| sizeof(cmux_frame_data_dlci2_ppp_18)) == 0, |
| "Incorrect data received"); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_dlci1_close_open) |
| { |
| uint32_t events; |
| |
| /* Close DLCI1 */ |
| zassert_true(modem_pipe_close_async(dlci1_pipe) == 0, "Failed to close DLCI1 pipe"); |
| k_msleep(100); |
| events = k_event_wait_all(&cmux_event_dte, (EVENT_CMUX_DLCI1_CLOSED), false, K_MSEC(100)); |
| |
| zassert_true((events & EVENT_CMUX_DLCI1_CLOSED), "DLCI1 not closed as expected"); |
| events = k_event_wait_all(&cmux_event_dce, (EVENT_CMUX_DLCI1_CLOSED), false, K_MSEC(100)); |
| |
| zassert_true((events & EVENT_CMUX_DLCI1_CLOSED), "DLCI1 not closed as expected"); |
| |
| /* Open DLCI1 */ |
| zassert_true(modem_pipe_open_async(dlci1_pipe) == 0, "Failed to open DLCI1 pipe"); |
| |
| k_msleep(100); |
| |
| events = k_event_wait_all(&cmux_event_dte, (EVENT_CMUX_DLCI1_OPEN), false, K_MSEC(100)); |
| |
| zassert_true((events & EVENT_CMUX_DLCI1_OPEN), "DLCI1 not opened as expected"); |
| events = k_event_wait_all(&cmux_event_dce, (EVENT_CMUX_DLCI1_OPEN), false, K_MSEC(100)); |
| |
| zassert_true((events & EVENT_CMUX_DLCI1_OPEN), "DLCI1 not opened as expected"); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_disconnect_connect) |
| { |
| uint32_t events; |
| |
| /* Disconnect CMUX */ |
| zassert_true(modem_pipe_close_async(dlci1_pipe) == 0, "Failed to close DLCI1"); |
| zassert_true(modem_pipe_close_async(dlci2_pipe) == 0, "Failed to close DLCI2"); |
| k_msleep(100); |
| |
| events = k_event_wait_all(&cmux_event_dte, |
| (EVENT_CMUX_DLCI1_CLOSED | EVENT_CMUX_DLCI2_CLOSED), false, |
| K_MSEC(100)); |
| |
| zassert_true((events & EVENT_CMUX_DLCI1_CLOSED), "Failed to close DLCI1"); |
| zassert_true((events & EVENT_CMUX_DLCI2_CLOSED), "Failed to close DLCI2"); |
| |
| /* Discard CMUX DLCI DISC commands */ |
| modem_backend_mock_reset(&bus_mock_dte); |
| zassert_true(modem_cmux_disconnect_async(&cmux_dte) == 0, "Failed to disconnect CMUX"); |
| |
| k_msleep(100); |
| |
| events = k_event_wait_all(&cmux_event_dte, (EVENT_CMUX_DISCONNECTED), false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DISCONNECTED), "Failed to disconnect CMUX"); |
| |
| /* Reconnect CMUX */ |
| zassert_true(modem_cmux_connect_async(&cmux_dte) == 0, "Failed to connect CMUX"); |
| |
| k_msleep(100); |
| |
| events = k_event_wait_all(&cmux_event_dte, (EVENT_CMUX_CONNECTED), false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_CONNECTED), "Failed to connect CMUX"); |
| |
| /* Open DLCI1 */ |
| zassert_true(modem_pipe_open_async(dlci1_pipe) == 0, "Failed to open DLCI1 pipe"); |
| |
| k_msleep(100); |
| |
| events = k_event_wait_all(&cmux_event_dte, (EVENT_CMUX_DLCI1_OPEN), false, K_MSEC(100)); |
| |
| zassert_true((events & EVENT_CMUX_DLCI1_OPEN), "DLCI1 not opened as expected"); |
| |
| /* Open DLCI2 */ |
| zassert_true(modem_pipe_open_async(dlci2_pipe) == 0, "Failed to open DLCI2 pipe"); |
| |
| k_msleep(100); |
| |
| events = k_event_wait_all(&cmux_event_dte, (EVENT_CMUX_DLCI2_OPEN), false, K_MSEC(100)); |
| |
| zassert_true((events & EVENT_CMUX_DLCI2_OPEN), "DLCI1 not opened as expected"); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_disconnect_connect_sync) |
| { |
| uint32_t events; |
| |
| zassert_true(modem_pipe_close(dlci1_pipe) == 0, "Failed to close DLCI1"); |
| zassert_true(modem_pipe_close(dlci2_pipe) == 0, "Failed to close DLCI2"); |
| events = k_event_wait_all(&cmux_event_dce, |
| (EVENT_CMUX_DLCI1_CLOSED | EVENT_CMUX_DLCI2_CLOSED), false, |
| K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI1_CLOSED), "DCE DLCI1 not closed as expected"); |
| zassert_true((events & EVENT_CMUX_DLCI2_CLOSED), "DCE DLCI2 not closed as expected"); |
| |
| zassert_true(modem_cmux_disconnect(&cmux_dte) == 0, "Failed to disconnect CMUX"); |
| zassert_true(modem_cmux_disconnect(&cmux_dte) == -EALREADY, |
| "Should already be disconnected"); |
| zassert_true(modem_cmux_disconnect(&cmux_dce) == -EALREADY, |
| "Should already be disconnected"); |
| |
| k_msleep(100); |
| |
| zassert_true(modem_cmux_connect(&cmux_dte) == 0, "Failed to connect CMUX"); |
| zassert_true(modem_cmux_connect(&cmux_dte) == -EALREADY, "Should already be connected"); |
| zassert_true(modem_cmux_connect(&cmux_dce) == -EALREADY, "Should already be connected"); |
| |
| zassert_true(modem_pipe_open(dlci1_pipe) == 0, "Failed to open DLCI1 pipe"); |
| zassert_true(modem_pipe_open(dlci2_pipe) == 0, "Failed to open DLCI2 pipe"); |
| events = k_event_wait_all(&cmux_event_dce, (EVENT_CMUX_DLCI1_OPEN | EVENT_CMUX_DLCI2_OPEN), |
| false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI1_OPEN), "DCE DLCI1 not open as expected"); |
| zassert_true((events & EVENT_CMUX_DLCI2_OPEN), "DCE DLCI2 not open as expected"); |
| } |
| |
| ZTEST(modem_cmux_pair, test_modem_cmux_dlci_close_open_sync) |
| { |
| uint32_t events; |
| |
| zassert_true(modem_pipe_close(dlci1_pipe) == 0, "Failed to close DLCI1"); |
| zassert_true(modem_pipe_close(dlci2_pipe) == 0, "Failed to close DLCI2"); |
| |
| events = k_event_wait_all(&cmux_event_dce, |
| (EVENT_CMUX_DLCI1_CLOSED | EVENT_CMUX_DLCI2_CLOSED), false, |
| K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI1_CLOSED), "DCE DLCI1 not closed as expected"); |
| zassert_true((events & EVENT_CMUX_DLCI2_CLOSED), "DCE DLCI2 not closed as expected"); |
| |
| zassert_true(modem_pipe_open(dlci1_pipe) == 0, "Failed to open DLCI1 pipe"); |
| zassert_true(modem_pipe_open(dlci2_pipe) == 0, "Failed to open DLCI2 pipe"); |
| /* Verify DCE side channels are open also */ |
| events = k_event_wait_all(&cmux_event_dce, (EVENT_CMUX_DLCI1_OPEN | EVENT_CMUX_DLCI2_OPEN), |
| false, K_MSEC(100)); |
| zassert_true((events & EVENT_CMUX_DLCI1_OPEN), "DCE DLCI1 not open as expected"); |
| zassert_true((events & EVENT_CMUX_DLCI2_OPEN), "DCE DLCI2 not open as expected"); |
| } |
| |
| ZTEST_SUITE(modem_cmux_pair, NULL, test_setup, test_before, NULL, NULL); |