net_env_project/tests/basic_test.cpp

263 lines
7.9 KiB
C++
Raw Permalink Normal View History

2026-06-18 05:01:37 +00:00
#include "app.hpp"
#include <cassert>
#include <cstring>
#include <ctime>
#include <iostream>
#include <string>
#include <vector>
// ═══════════════════════════════════════════════════════════════
// DAU 单元测试
// ═══════════════════════════════════════════════════════════════
/**
* @brief DAU_Process
*
* @requirement(name="基础通用通讯功能", id="SRS-F-01-001")
* 线 ID
*/
static void test_DAU_Process_ValidFrame()
{
RawDataFrame input;
input.busType = BusType::CAN;
input.len = 8;
input.timestamp = std::time(nullptr);
for (uint8_t i = 0; i < input.len; ++i) {
input.data[i] = 0x10 + i;
}
ValidData output;
std::string errorLog;
bool ok = dau::DAU_Process(input, output, errorLog);
assert(ok == true);
assert(output.dataLen == input.len);
assert(output.sourceBus == BusType::CAN);
assert(errorLog.empty());
std::cout << "[PASS] test_DAU_Process_ValidFrame\n";
}
/**
* @brief DAU_Process 0xFF
*
* @requirement(name="基础通用通讯功能", id="SRS-F-01-001")
* /
*/
static void test_DAU_Process_ErrorFrame()
{
RawDataFrame input;
input.busType = BusType::RS422;
input.len = 4;
input.timestamp = std::time(nullptr);
// 全 0xFF 视为错误帧
for (uint8_t i = 0; i < input.len; ++i) {
input.data[i] = 0xFF;
}
ValidData output;
std::string errorLog;
bool ok = dau::DAU_Process(input, output, errorLog);
assert(ok == false);
assert(!errorLog.empty());
std::cout << "[PASS] test_DAU_Process_ErrorFrame\n";
}
/**
* @brief
*
* @requirement(name="基础通用通讯功能", id="SRS-F-01-001")
* /
*/
static void test_DAU_SleepMode()
{
dau::DAU_SetSleep(true);
RawDataFrame input;
input.busType = BusType::Ethernet;
input.len = 2;
input.timestamp = std::time(nullptr);
input.data[0] = 0x01;
input.data[1] = 0x02;
ValidData output;
std::string errorLog;
bool ok = dau::DAU_Process(input, output, errorLog);
assert(ok == false);
assert(!errorLog.empty());
std::cout << "[PASS] test_DAU_SleepMode\n";
dau::DAU_SetSleep(false); // 恢复
}
// ═══════════════════════════════════════════════════════════════
// PPU 单元测试
// ═══════════════════════════════════════════════════════════════
/**
* @brief PPU_Check
*
* @requirement(name="协议兼容与互通信功能", id="SRS-F-01-002")
*
*/
static void test_PPU_Check_ValidStandard()
{
CanFrame frame;
frame.id = 0x100;
frame.isExtended = false;
frame.isCanFd = false;
frame.dataLen = 8;
std::string reason;
bool ok = ppu::PPU_Check(frame, reason);
assert(ok == true);
std::cout << "[PASS] test_PPU_Check_ValidStandard\n";
}
/**
* @brief PPU_Check ID
*
* @requirement(name="协议兼容与互通信功能", id="SRS-F-01-002")
*
*/
static void test_PPU_Check_InvalidStandardId()
{
CanFrame frame;
frame.id = 0x800; // 超出 11 位范围
frame.isExtended = false;
frame.isCanFd = false;
frame.dataLen = 8;
std::string reason;
bool ok = ppu::PPU_Check(frame, reason);
assert(ok == false);
assert(!reason.empty());
std::cout << "[PASS] test_PPU_Check_InvalidStandardId\n";
}
/**
* @brief PPU_Convert CAN2.0->CANFD
*
* @requirement(name="协议兼容与互通信功能", id="SRS-F-01-002")
* ARINC825
*/
static void test_PPU_Convert_Can20ToFd()
{
CanFrame input;
input.id = 0x200;
input.isExtended = false;
input.isCanFd = false;
input.dataLen = 8;
input.timestamp = std::time(nullptr);
for (uint8_t i = 0; i < input.dataLen; ++i) {
input.data[i] = 0x30 + i;
}
CompatibleFrame output;
std::string log;
bool ok = ppu::PPU_Convert(input, output, log);
assert(ok == true);
assert(output.id == input.id);
assert(output.dataLen == 8);
assert(output.isExtended == false);
std::cout << "[PASS] test_PPU_Convert_Can20ToFd\n";
}
// ═══════════════════════════════════════════════════════════════
// DSU 单元测试
// ═══════════════════════════════════════════════════════════════
/**
* @brief DSU_Write DSU_Query
*
* @requirement(name="数据存储功能", id="SRS-F-02-001")
* 线
* @requirement(name="数据管理与回放功能", id="SRS-F-02-002")
*
*/
static void test_DSU_WriteAndQuery()
{
time_t now = std::time(nullptr);
std::vector<uint8_t> block = {0x01, 0x02, 0x03};
bool writeOk = dsu::DSU_Write(block, 1, now);
assert(writeOk == true);
QueryCondition qc;
qc.startTime = now - 1;
qc.endTime = now + 1;
qc.channelId = 1;
qc.maxResults = 10;
std::vector<std::vector<uint8_t>> results;
std::string log;
bool queryOk = dsu::DSU_Query(qc, results, log);
assert(queryOk == true);
assert(results.size() >= 1);
assert(results[0].size() == 3);
assert(results[0][0] == 0x01);
std::cout << "[PASS] test_DSU_WriteAndQuery\n";
}
/**
* @brief DSU_Replay
*
* @requirement(name="数据管理与回放功能", id="SRS-F-02-002")
*
*/
static void test_DSU_Replay()
{
time_t now = std::time(nullptr);
// 写入多块数据
dsu::DSU_Write({0x10, 0x11}, 2, now);
dsu::DSU_Write({0x20, 0x21, 0x22}, 2, now + 1);
QueryCondition qc;
qc.startTime = now;
qc.endTime = now + 2;
qc.channelId = 2;
qc.maxResults = 10;
std::vector<uint8_t> replayOut;
std::string log;
bool replayOk = dsu::DSU_Replay(qc, replayOut, log);
assert(replayOk == true);
assert(replayOut.size() == 5); // 2 + 3 bytes
assert(replayOut[0] == 0x10);
assert(replayOut[2] == 0x20);
std::cout << "[PASS] test_DSU_Replay\n";
}
// ═══════════════════════════════════════════════════════════════
// 主测试入口
// ═══════════════════════════════════════════════════════════════
int main()
{
std::cout << "=== Avionics Network Environment - Basic Tests ===\n\n";
// DAU 测试
test_DAU_Process_ValidFrame();
test_DAU_Process_ErrorFrame();
test_DAU_SleepMode();
// PPU 测试
test_PPU_Check_ValidStandard();
test_PPU_Check_InvalidStandardId();
test_PPU_Convert_Can20ToFd();
// DSU 测试
test_DSU_WriteAndQuery();
test_DSU_Replay();
std::cout << "\n=== All tests passed! ===\n";
return 0;
}