254 lines
8.2 KiB
C
254 lines
8.2 KiB
C
/*
|
|
* test-at.c
|
|
* SPDX-FileCopyrightText: 2016-2025 BlueALSA developers
|
|
* SPDX-License-Identifier: MIT
|
|
*/
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
#include <check.h>
|
|
|
|
#include "at.h"
|
|
#include "hfp.h"
|
|
|
|
#include "inc/check.inc"
|
|
|
|
CK_START_TEST(test_at_type2str) {
|
|
ck_assert_str_eq(at_type2str(AT_TYPE_RAW), "RAW");
|
|
ck_assert_str_eq(at_type2str(AT_TYPE_RESP), "RESP");
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_build) {
|
|
|
|
char buffer[256];
|
|
|
|
/* build commands */
|
|
ck_assert_str_eq(at_build(buffer, sizeof(buffer), AT_TYPE_RAW, "\r\nRING", NULL), "\r\nRING");
|
|
ck_assert_str_eq(at_build(buffer, sizeof(buffer), AT_TYPE_CMD, "+CLCC", NULL), "AT+CLCC\r");
|
|
ck_assert_str_eq(at_build(buffer, sizeof(buffer), AT_TYPE_CMD_GET, "+COPS", NULL), "AT+COPS?\r");
|
|
ck_assert_str_eq(at_build(buffer, sizeof(buffer), AT_TYPE_CMD_SET, "+BCS", "1"), "AT+BCS=1\r");
|
|
ck_assert_str_eq(at_build(buffer, sizeof(buffer), AT_TYPE_CMD_TEST, "+CIND", NULL), "AT+CIND=?\r");
|
|
|
|
/* build response result code */
|
|
ck_assert_str_eq(at_build(buffer, sizeof(buffer), AT_TYPE_RESP, "+CIND", ""), "\r\n+CIND:\r\n");
|
|
|
|
/* build unsolicited result code */
|
|
ck_assert_str_eq(at_build(buffer, sizeof(buffer), AT_TYPE_RESP, NULL, "OK"), "\r\nOK\r\n");
|
|
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_invalid) {
|
|
struct bt_at at;
|
|
/* invalid AT command lines */
|
|
ck_assert_ptr_eq(at_parse("ABC\r", &at), NULL);
|
|
ck_assert_ptr_eq(at_parse("AT+CLCK?", &at), NULL);
|
|
ck_assert_ptr_eq(at_parse("\r\r", &at), NULL);
|
|
ck_assert_ptr_eq(at_parse("\r\nOK", &at), NULL);
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_cmd) {
|
|
struct bt_at at;
|
|
/* parse AT plain command */
|
|
ck_assert_ptr_ne(at_parse("AT+CLCC\r", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_CMD);
|
|
ck_assert_str_eq(at.command, "+CLCC");
|
|
ck_assert_ptr_eq(at.value, NULL);
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_cmd_get) {
|
|
struct bt_at at;
|
|
/* parse AT GET command */
|
|
ck_assert_ptr_ne(at_parse("AT+COPS?\r", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_CMD_GET);
|
|
ck_assert_str_eq(at.command, "+COPS");
|
|
ck_assert_ptr_eq(at.value, NULL);
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_cmd_set) {
|
|
struct bt_at at;
|
|
/* parse AT SET command */
|
|
ck_assert_ptr_ne(at_parse("AT+CLCK=\"SC\",0,\"1234\"\r", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_CMD_SET);
|
|
ck_assert_str_eq(at.command, "+CLCK");
|
|
ck_assert_str_eq(at.value, "\"SC\",0,\"1234\"");
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_cmd_test) {
|
|
struct bt_at at;
|
|
/* parse AT TEST command */
|
|
ck_assert_ptr_ne(at_parse("AT+COPS=?\r", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_CMD_TEST);
|
|
ck_assert_str_eq(at.command, "+COPS");
|
|
ck_assert_ptr_eq(at.value, NULL);
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_resp) {
|
|
struct bt_at at;
|
|
/* parse response result code */
|
|
ck_assert_ptr_ne(at_parse("\r\n+CIND:0,0,1,4,0,4,0\r\n", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_RESP);
|
|
ck_assert_str_eq(at.command, "+CIND");
|
|
ck_assert_str_eq(at.value, "0,0,1,4,0,4,0");
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_resp_empty) {
|
|
struct bt_at at;
|
|
/* parse response result code with empty value */
|
|
ck_assert_ptr_ne(at_parse("\r\n+CIND:\r\n", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_RESP);
|
|
ck_assert_str_eq(at.command, "+CIND");
|
|
ck_assert_str_eq(at.value, "");
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_resp_unsolicited) {
|
|
struct bt_at at;
|
|
/* parse unsolicited result code */
|
|
ck_assert_ptr_ne(at_parse("\r\nRING\r\n", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_RESP);
|
|
ck_assert_str_eq(at.command, "");
|
|
ck_assert_str_eq(at.value, "RING");
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_case_sensitivity) {
|
|
struct bt_at at;
|
|
/* case-insensitive command and case-sensitive value */
|
|
ck_assert_ptr_ne(at_parse("aT+tEsT=VaLuE\r", &at), NULL);
|
|
ck_assert_int_eq(at.type, AT_TYPE_CMD_SET);
|
|
ck_assert_str_eq(at.command, "+TEST");
|
|
ck_assert_str_eq(at.value, "VaLuE");
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_multiple_cmds) {
|
|
struct bt_at at;
|
|
/* concatenated commands */
|
|
const char *cmd = "\r\nOK\r\n\r\n+COPS:1\r\n";
|
|
ck_assert_str_eq(at_parse(cmd, &at), &cmd[6]);
|
|
ck_assert_int_eq(at.type, AT_TYPE_RESP);
|
|
ck_assert_str_eq(at.command, "");
|
|
ck_assert_str_eq(at.value, "OK");
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_set_bia) {
|
|
|
|
const bool state_ok1[__HFP_IND_MAX] = { 0, true, true, true, true, true, true, true };
|
|
const bool state_ok2[__HFP_IND_MAX] = { 0, true, false, true, true, true, true, false };
|
|
const bool state_ok3[__HFP_IND_MAX] = { 0, true, false, false, false, true, true, true };
|
|
const bool state_ok4[__HFP_IND_MAX] = { 0, true, true, false, false, true, true, true };
|
|
bool state[__HFP_IND_MAX] = { 0 };
|
|
|
|
ck_assert_int_eq(at_parse_set_bia("1,1,1,1,1,1,1", state), 0);
|
|
ck_assert_mem_eq(state, state_ok1, sizeof(state));
|
|
|
|
ck_assert_int_eq(at_parse_set_bia("1,0,1,1,1,1,0", state), 0);
|
|
ck_assert_mem_eq(state, state_ok2, sizeof(state));
|
|
|
|
/* omitted values shall not be changed */
|
|
ck_assert_int_eq(at_parse_set_bia(",,0,0,,,1", state), 0);
|
|
ck_assert_mem_eq(state, state_ok3, sizeof(state));
|
|
|
|
/* truncated values shall not be changed */
|
|
ck_assert_int_eq(at_parse_set_bia("1,1", state), 0);
|
|
ck_assert_mem_eq(state, state_ok4, sizeof(state));
|
|
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_get_cind) {
|
|
|
|
enum hfp_ind indmap[20];
|
|
enum hfp_ind indmap_ok[20];
|
|
|
|
/* parse +CIND response result code */
|
|
ck_assert_int_eq(at_parse_get_cind("(\"call\",(0,1)),(\"xxx\",(0-3)),(\"signal\",(0-5))", indmap), 0);
|
|
memset(indmap_ok, HFP_IND_NULL, sizeof(indmap_ok));
|
|
indmap_ok[0] = HFP_IND_CALL;
|
|
indmap_ok[2] = HFP_IND_SIGNAL;
|
|
ck_assert_mem_eq(indmap, indmap_ok, sizeof(indmap));
|
|
|
|
/* parse +CIND response with white-spaces */
|
|
ck_assert_int_eq(at_parse_get_cind(" ( \"call\", ( 0, 1 ) ), ( \"signal\", ( 0-3 ) )", indmap), 0);
|
|
|
|
/* parse +CIND invalid response */
|
|
ck_assert_int_eq(at_parse_get_cind("(incorrect,1-2)", indmap), -1);
|
|
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_set_cmer) {
|
|
|
|
const unsigned int cmer_ok1[5] = { 3, 0, 0, 1, 0 };
|
|
const unsigned int cmer_ok2[5] = { 2, 0, 0, 1, 0 };
|
|
unsigned int cmer[5];
|
|
|
|
/* parse +CMER value */
|
|
ck_assert_int_eq(at_parse_set_cmer("3,0,0,1,0", cmer), 0);
|
|
ck_assert_mem_eq(cmer, cmer_ok1, sizeof(cmer));
|
|
|
|
/* parse +CMER value with white-spaces */
|
|
ck_assert_int_eq(at_parse_set_cmer("3, 0, 0 , 1 , 0", cmer), 0);
|
|
ck_assert_mem_eq(cmer, cmer_ok1, sizeof(cmer));
|
|
|
|
/* parse +CMER value with less elements */
|
|
ck_assert_int_eq(at_parse_set_cmer("2,0", cmer), 0);
|
|
ck_assert_mem_eq(cmer, cmer_ok2, sizeof(cmer));
|
|
|
|
/* parse +CMER empty value */
|
|
ck_assert_int_eq(at_parse_set_cmer("", cmer), 0);
|
|
ck_assert_mem_eq(cmer, cmer_ok2, sizeof(cmer));
|
|
|
|
/* parse +CMER invalid value */
|
|
ck_assert_int_eq(at_parse_set_cmer("3,error", cmer), -1);
|
|
|
|
} CK_END_TEST
|
|
|
|
CK_START_TEST(test_at_parse_set_xapl) {
|
|
|
|
uint16_t vendor, product, version;
|
|
uint8_t features;
|
|
|
|
ck_assert_int_eq(at_parse_set_xapl("ABCD-1234-0100,10", &vendor, &product, &version, &features), 0);
|
|
ck_assert_int_eq(vendor, 0xABCD);
|
|
ck_assert_int_eq(product, 0x1234);
|
|
ck_assert_int_eq(version, 0x0100);
|
|
ck_assert_int_eq(features, 10);
|
|
|
|
/* parse invalid feature value which shall be a 10-base number */
|
|
ck_assert_int_eq(at_parse_set_xapl("ABCD-1234-0100,1A", &vendor, &product, &version, &features), -1);
|
|
|
|
/* parse invalid number of parameters */
|
|
ck_assert_int_eq(at_parse_set_xapl("ABCD-1234,10", &vendor, &product, &version, &features), -1);
|
|
|
|
} CK_END_TEST
|
|
|
|
int main(void) {
|
|
|
|
Suite *s = suite_create(__FILE__);
|
|
TCase *tc = tcase_create(__FILE__);
|
|
SRunner *sr = srunner_create(s);
|
|
|
|
suite_add_tcase(s, tc);
|
|
|
|
tcase_add_test(tc, test_at_type2str);
|
|
tcase_add_test(tc, test_at_build);
|
|
tcase_add_test(tc, test_at_parse_invalid);
|
|
tcase_add_test(tc, test_at_parse_cmd);
|
|
tcase_add_test(tc, test_at_parse_cmd_get);
|
|
tcase_add_test(tc, test_at_parse_cmd_set);
|
|
tcase_add_test(tc, test_at_parse_cmd_test);
|
|
tcase_add_test(tc, test_at_parse_resp);
|
|
tcase_add_test(tc, test_at_parse_resp_empty);
|
|
tcase_add_test(tc, test_at_parse_resp_unsolicited);
|
|
tcase_add_test(tc, test_at_parse_case_sensitivity);
|
|
tcase_add_test(tc, test_at_parse_multiple_cmds);
|
|
tcase_add_test(tc, test_at_parse_set_bia);
|
|
tcase_add_test(tc, test_at_parse_get_cind);
|
|
tcase_add_test(tc, test_at_parse_set_cmer);
|
|
tcase_add_test(tc, test_at_parse_set_xapl);
|
|
|
|
srunner_run_all(sr, CK_ENV);
|
|
int nf = srunner_ntests_failed(sr);
|
|
srunner_free(sr);
|
|
|
|
return nf == 0 ? 0 : 1;
|
|
}
|