整理并合并
#include <stdio.h>
#include <string.h>
#include <assert.h>
// 模拟串口发送缓冲区
#define TX_
BUFFER_
SIZE 256
unsigned char uart_tx_
buffer[TX_
BUFFER_
SIZE];
unsigned int tx_
buffer_index = 0;
unsigned int tx_byte_count = 0;
// 模拟发送数据记录
typedef struct {
unsigned char data[TX_
BUFFER_
SIZE];
unsigned int count;
unsigned int sequence[TX_
BUFFER_
SIZE];
unsigned int sequence_count;
} uart_transmit_log_t;
uart_transmit_log_t transmit_log;
// 模拟的MCU串口发送函数
void Uart_PutChar
(unsigned char value
) {
printf
("[UART发送] 字节: 0x%02X
('%c'
)\\n", value,
(value >= 32 && value <= 126
) ? value : '.'
);
tx_byte_count++;
}
// 需要测试的目标函数
void uart_transmit_output
(unsigned char value
) {
// 实际使用时需要替换为具体的MCU串口发送函数
extern void Uart_PutChar
(unsigned char value
);
Uart_PutChar
(value
); // 串口发送函数
// 记录发送数据用于测试验证
if
(tx_
buffer_index < TX_
BUFFER_
SIZE) {
uart_tx_
buffer[tx_
buffer_index++] = value;
transmit_log.data[transmit_log.count++] = value;
transmit_log.sequence[transmit_log.sequence_count++] = tx_byte_count;
}
}
// 测试辅助函数
void reset_test_environment
(void
) {
memset
(uart_tx_
buffer, 0, TX_
BUFFER_
SIZE);
memset
(&transmit_log, 0,
sizeof
(transmit_log
));
tx_
buffer_index = 0;
tx_byte_count = 0;
}
void print_hex_data
(const unsigned char *data, unsigned int len
) {
printf
("十六进制数据: "
);
for
(unsigned int i = 0; i < len; i++
) {
printf
("%02X ", data[i]
);
}
printf
("\\n"
);
}
void print_ascii_data
(const unsigned char *data, unsigned int len
) {
printf
("ASCII数据: "
);
for
(unsigned int i = 0; i < len; i++
) {
if
(data[i] >= 32 && data[i] <= 126
) {
printf
("%c", data[i]
);
} else {
printf
("."
);
}
}
printf
("\\n"
);
}
// 测试用例
void test_single_byte_transmission
(void
) {
printf
("=== 测试1: 单字节发送 ===\\n"
);
reset_test_environment
();
unsigned char test_byte = 0x55;
uart_transmit_output
(test_byte
);
assert
(uart_tx_
buffer[0] == test_byte
);
assert
(transmit_log.count == 1
);
assert
(transmit_log.data[0] == test_byte
);
assert
(tx_byte_count == 1
);
printf
("✓ 单字节发送测试通过\\n"
);
printf
("发送字节: 0x%02X\\n", test_byte
);
printf
("总发送
字节数: %u\\n\\n", tx_byte_count
);
}
void test_multiple_
bytes_transmission
(void
) {
printf
("=== 测试2: 多字节发送 ===\\n"
);
reset_test_environment
();
unsigned char test_data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F}; // "Hello"
unsigned int data_len =
sizeof
(test_data
);
for
(unsigned int i = 0; i < data_len; i++
) {
uart_transmit_output
(test_data[i]
);
}
assert
(transmit_log.count == data_len
);
assert
(tx_byte_count == data_len
);
// 验证发送顺序
和内容
for
(unsigned int i = 0; i < data_len; i++
) {
assert
(uart_tx_
buffer[i] == test_data[i]
);
assert
(transmit_log.data[i] == test_data[i]
);
}
printf
("✓ 多字节发送测试通过\\n"
);
print_hex_data
(test_data, data_len
);
print_ascii_data
(test_data, data_len
);
printf
("总发送
字节数: %u\\n\\n", tx_byte_count
);
}
void test_special_characters_transmission
(void
) {
printf
("=== 测试3: 特殊字符发送 ===\\n"
);
reset_test_environment
();
unsigned char special_
chars[] = {0x00, 0xFF, 0x0A, 0x0D, 0x7F}; // NULL, 255, LF, CR, DEL
unsigned int
chars_len =
sizeof
(special_
chars);
for
(unsigned int i = 0; i <
chars_len; i++
) {
uart_transmit_output
(special_
chars[i]
);
}
assert
(transmit_log.count ==
chars_len
);
assert
(tx_byte_count ==
chars_len
);
printf
("✓ 特殊字符发送测试通过\\n"
);
printf
("测试字符: NULL
(0x00
), 255
(0xFF
), LF
(0x0A
), CR
(0x0D
), DEL
(0x7F
)\\n"
);
print_hex_data
(special_
chars,
chars_len
);
printf
("总发送
字节数: %u\\n\\n", tx_byte_count
);
}
void test_continuous_transmission
(void
) {
printf
("=== 测试4: 连续发送测试 ===\\n"
);
reset_test_environment
();
unsigned int total_
bytes = 50;
for
(unsigned int i = 0; i < total_
bytes; i++
) {
uart_transmit_output
(i & 0xFF
);
}
assert
(transmit_log.count == total_
bytes);
assert
(tx_byte_count == total_
bytes);
// 验证发送序列
for
(unsigned int i = 0; i < total_
bytes; i++
) {
assert
(transmit_log.data[i] ==
(i & 0xFF
));
assert
(transmit_log.sequence[i] == i + 1
); // 序列号从1开始
}
printf
("✓ 连续发送测试通过\\n"
);
printf
("连续发送 %u 个字节\\n", total_
bytes);
printf
("总发送
字节数: %u\\n\\n", tx_byte_count
);
}
void test_protocol_message_transmission
(void
) {
printf
("=== 测试5: 协议消息发送 ===\\n"
);
reset_test_environment
();
// 模拟一个完整的通信协议消息
unsigned char protocol_message[] = {
0xAA, 0x55, // 帧头
0x08, // 数据长度
0x01, 0x02, 0x03, 0x04, // 数据内容
0x05, 0x06, 0x07, 0x08,
0x5A, 0xA5 // 帧尾
};
unsigned int msg_len =
sizeof
(protocol_message
);
for
(unsigned int i = 0; i < msg_len; i++
) {
uart_transmit_output
(protocol_message[i]
);
}
assert
(transmit_log.count == msg_len
);
assert
(tx_byte_count == msg_len
);
// 验证帧结构
assert
(uart_tx_
buffer[0] == 0xAA
); // 帧头第一部分
assert
(uart_tx_
buffer[1] == 0x55
); // 帧头第二部分
assert
(uart_tx_
buffer[2] == 0x08
); // 数据长度
assert
(uart_tx_
buffer[msg_len - 2] == 0x5A
); // 帧尾第一部分
assert
(uart_tx_
buffer[msg_len - 1] == 0xA5
); // 帧尾第二部分
printf
("✓ 协议消息发送测试通过\\n"
);
printf
("协议消息长度: %u 字节\\n", msg_len
);
print_hex_data
(protocol_message, msg_len
);
printf
("总发送
字节数: %u\\n\\n", tx_byte_count
);
}
void run_all_tests
(void
) {
printf
("串口发送功能测试套件\\n"
);
printf
("======================\\n\\n"
);
test_single_byte_transmission
();
test_multiple_
bytes_transmission
();
test_special_characters_transmission
();
test_continuous_transmission
();
test_protocol_message_transmission
();
printf
("======================\\n"
);
printf
("所有测试用例执行完成！\\n"
);
printf
("总测试用例数: 5\\n"
);
printf
("所有断言检查通过 ✓\\n"
);
}
int main
() {
run_all_tests
();
return 0;
}
#include <stdio.h>
#include <string.h>
#include <assert.h>
// 测试用缓冲区定义
#define
BUFFER_
SIZE 128
unsigned char wifi_uart_rx_
buf[
BUFFER_
SIZE];
unsigned char *rx_
buf_in = wifi_uart_rx_
buf;
unsigned char *rx_
buf_out = wifi_uart_rx_
buf;
// 模拟通讯结构
typedef struct {
unsigned char Tx[256];
} HAL_UART_TuyaWifiComm_MGR;
HAL_UART_TuyaWifiComm_MGR comm_mgr;
#define TUYA_FRAME_DATA_START 10
// 函数声明
void uart_receive_input
(unsigned char value
);
void uart_receive_
buff_input
(unsigned char value[], unsigned short data_len
);
unsigned short set_wifi_uart_byte
(unsigned short dest, unsigned char byte
);
unsigned short set_wifi_uart_
buffer
(unsigned short dest, const unsigned char *src, unsigned short len
);
unsigned char with_data_rx
buff
(void
);
unsigned char take_byte_rx
buff
(void
);
void
Buffercopy
(unsigned char *dest, const unsigned char *src, unsigned short len
);
void reset_
buffer
(void
);
// 测试函数
void test_uart_receive_single_byte
(void
);
void test_uart_receive_multiple_
bytes(void
);
void test_
buffer_wrap_around
(void
);
void test_with_data_check
(void
);
void test_take_byte_function
(void
);
void test_set_wifi_uart_functions
(void
);
void run_all_tests
(void
);
// 重置缓冲区
void reset_
buffer
(void
) {
memset
(wifi_uart_rx_
buf, 0,
BUFFER_
SIZE);
rx_
buf_in = wifi_uart_rx_
buf;
rx_
buf_out = wifi_uart_rx_
buf;
memset
(comm_mgr.Tx, 0,
sizeof
(comm_mgr.Tx
));
}
void
Buffercopy
(unsigned char *dest, const unsigned char *src, unsigned short len
) {
memcpy
(dest, src, len
);
}
void uart_receive_input
(unsigned char value
) {
//
计算可用空间
unsigned int used_space;
if
(rx_
buf_in >= rx_
buf_out
) {
used_space = rx_
buf_in - rx_
buf_out;
} else {
used_space =
(rx_
buf_in - wifi_uart_rx_
buf) +
(BUFFER_
SIZE -
(rx_
buf_out - wifi_uart_rx_
buf));
}
if
(used_space >=
BUFFER_
SIZE - 1
) {
printf
("[缓冲区满] 丢弃字节: 0x%02X\n", value
);
return;
}
// 写入数据
*rx_
buf_in++ = value;
// 处理缓冲区回绕
if
(rx_
buf_in >= wifi_uart_rx_
buf +
BUFFER_
SIZE) {
rx_
buf_in = wifi_uart_rx_
buf;
}
}
void uart_receive_
buff_input
(unsigned char value[], unsigned short data_len
) {
unsigned short i = 0;
for
(i = 0; i < data_len; i++
) {
uart_receive_input
(value[i]
);
}
}
unsigned short set_wifi_uart_byte
(unsigned short dest, unsigned char byte
) {
unsigned char *obj =
(unsigned char *
)comm_mgr.Tx + TUYA_FRAME_DATA_START + dest;
*obj = byte;
dest += 1;
return dest;
}
unsigned short set_wifi_uart_
buffer
(unsigned short dest, const unsigned char *src, unsigned short len
) {
unsigned char *obj =
(unsigned char *
)comm_mgr.Tx + TUYA_FRAME_DATA_START + dest;
Buffercopy
(obj, src, len
);
dest += len;
return dest;
}
unsigned char with_data_rx
buff
(void
) {
return
(rx_
buf_in != rx_
buf_out
) ? 1 : 0;
}
unsigned char take_byte_rx
buff
(void
) {
unsigned char value = 0;
if
(rx_
buf_out != rx_
buf_in
) {
value = *rx_
buf_out++;
// 处理缓冲区回绕
if
(rx_
buf_out >= wifi_uart_rx_
buf +
BUFFER_
SIZE) {
rx_
buf_out = wifi_uart_rx_
buf;
}
}
return value;
}
void test_uart_receive_single_byte
(void
) {
printf
("测试1: 单字节接收功能\n"
);
reset_
buffer
();
uart_receive_input
(0x55
);
assert
(with_data_rx
buff
() == 1
);
assert
(take_byte_rx
buff
() == 0x55
);
assert
(with_data_rx
buff
() == 0
);
printf
(" ✓ 单字节接收测试通过\n"
);
}
void test_uart_receive_multiple_
bytes(void
) {
printf
("测试2: 多字节接收功能\n"
);
reset_
buffer
();
unsigned char test_data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
uart_receive_
buff_input
(test_data, 5
);
assert
(with_data_rx
buff
() == 1
);
for
(int i = 0; i < 5; i++
) {
assert
(take_byte_rx
buff
() == test_data[i]
);
}
assert
(with_data_rx
buff
() == 0
);
printf
(" ✓ 多字节接收测试通过\n"
);
}
void test_
buffer_wrap_around
(void
) {
printf
("测试3: 缓冲区循环覆盖测试\n"
);
reset_
buffer
();
// 填充到缓冲区末尾
for
(int i = 0; i <
BUFFER_
SIZE - 2; i++
) {
uart_receive_input
(i & 0xFF
);
}
// 验证数据读取
for
(int i = 0; i <
BUFFER_
SIZE - 2; i++
) {
assert
(take_byte_rx
buff
() ==
(i & 0xFF
));
}
// 触发循环写入
uart_receive_input
(0xAA
);
uart_receive_input
(0xBB
);
assert
(take_byte_rx
buff
() == 0xAA
);
assert
(take_byte_rx
buff
() == 0xBB
);
assert
(with_data_rx
buff
() == 0
);
printf
(" ✓ 缓冲区循环测试通过\n"
);
}
void test_with_data_check
(void
) {
printf
("测试4: 数据存在性检查\n"
);
reset_
buffer
();
assert
(with_data_rx
buff
() == 0
);
uart_receive_input
(0x10
);
assert
(with_data_rx
buff
() == 1
);
take_byte_rx
buff
();
assert
(with_data_rx
buff
() == 0
);
printf
(" ✓ 数据存在性检查测试通过\n"
);
}
void test_take_byte_function
(void
) {
printf
("测试5: 字节读取功能\n"
);
reset_
buffer
();
uart_receive_input
(0x20
);
uart_receive_input
(0x30
);
assert
(take_byte_rx
buff
() == 0x20
);
assert
(take_byte_rx
buff
() == 0x30
);
printf
(" ✓ 字节读取功能测试通过\n"
);
}
void test_set_wifi_uart_functions
(void
) {
printf
("测试6: WiFi UART设置功能\n"
);
reset_
buffer
();
// 测试单字节设置
unsigned short pos = set_wifi_uart_byte
(0, 0x77
);
assert
(pos == 1
);
assert
(comm_mgr.Tx[TUYA_FRAME_DATA_START] == 0x77
);
// 测试缓冲区设置
unsigned char test_
buf[] = {0x88, 0x99, 0xAA};
pos = set_wifi_uart_
buffer
(pos, test_
buf, 3
);
assert
(pos == 4
);
assert
(comm_mgr.Tx[TUYA_FRAME_DATA_START + 1] == 0x88
);
assert
(comm_mgr.Tx[TUYA_FRAME_DATA_START + 2] == 0x99
);
assert
(comm_mgr.Tx[TUYA_FRAME_DATA_START + 3] == 0xAA
);
printf
(" ✓ WiFi UART设置功能测试通过\n"
);
}
void run_all_tests
(void
) {
test_uart_receive_single_byte
();
test_uart_receive_multiple_
bytes();
test_
buffer_wrap_around
();
test_with_data_check
();
test_take_byte_function
();
test_set_wifi_uart_functions
();
}
int main
() {
printf
("=== 串口通信功能测试套件 ===\n\n"
);
run_all_tests
();
printf
("\n=== 所有测试完成 ===\n"
);
return 0;
}
本文介绍了一种使用预处理宏定义来计算缓冲区的字节数和字符数的方法，并通过一个示例展示了如何应用这些宏定义。
扫一扫
1150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
