326 lines
10 KiB
C++
326 lines
10 KiB
C++
#include <gtest/gtest.h>
|
|
#include "pipeline/common/config_parser.hpp"
|
|
|
|
using namespace pipeline;
|
|
|
|
// 测试配置数据结构的默认值
|
|
TEST(ConfigParserTest, DefaultValues) {
|
|
// 测试InputSourceConfig默认值
|
|
InputSourceConfig input_source;
|
|
EXPECT_EQ(input_source.buffer_size, 30);
|
|
EXPECT_TRUE(input_source.type.empty());
|
|
EXPECT_TRUE(input_source.name.empty());
|
|
EXPECT_TRUE(input_source.url.empty());
|
|
EXPECT_TRUE(input_source.outputs.empty());
|
|
|
|
// 测试InputConfig默认值
|
|
InputConfig input;
|
|
EXPECT_EQ(input.max_batch_size, 4);
|
|
EXPECT_TRUE(input.sources.empty());
|
|
|
|
// 测试ModelConfig默认值
|
|
ModelConfig model;
|
|
EXPECT_TRUE(model.engine_path.empty());
|
|
EXPECT_EQ(model.input_shape, std::vector<int>({3, 640, 640}));
|
|
EXPECT_EQ(model.precision, "FP16");
|
|
EXPECT_FLOAT_EQ(model.threshold.conf, 0.5f);
|
|
EXPECT_FLOAT_EQ(model.threshold.nms, 0.45f);
|
|
EXPECT_EQ(model.gpu_id, 0);
|
|
EXPECT_TRUE(model.labels.empty());
|
|
EXPECT_TRUE(model.version.empty());
|
|
|
|
// 测试RenderConfig默认值
|
|
RenderConfig render;
|
|
EXPECT_EQ(render.window.name, "Detection Results");
|
|
EXPECT_EQ(render.window.width, 1280);
|
|
EXPECT_EQ(render.window.height, 720);
|
|
EXPECT_FALSE(render.window.fullscreen);
|
|
|
|
// 测试默认渲染样式
|
|
EXPECT_EQ(render.default_style.box_color, cv::Scalar(0, 255, 0));
|
|
EXPECT_EQ(render.default_style.text_color, cv::Scalar(255, 255, 255));
|
|
EXPECT_FLOAT_EQ(render.default_style.transparency, 0.0f);
|
|
EXPECT_EQ(render.default_style.box_thickness, 2);
|
|
EXPECT_DOUBLE_EQ(render.default_style.font_scale, 0.5);
|
|
EXPECT_EQ(render.default_style.font_thickness, 1);
|
|
|
|
// 测试性能指标显示设置
|
|
EXPECT_TRUE(render.metrics.show_fps);
|
|
EXPECT_TRUE(render.metrics.show_inference_time);
|
|
EXPECT_TRUE(render.metrics.show_gpu_usage);
|
|
EXPECT_EQ(render.metrics.update_interval_ms, 1000);
|
|
|
|
// 测试OutputTargetConfig默认值
|
|
OutputTargetConfig output_target;
|
|
EXPECT_TRUE(output_target.type.empty());
|
|
EXPECT_TRUE(output_target.name.empty());
|
|
EXPECT_TRUE(output_target.path.empty());
|
|
EXPECT_EQ(output_target.fps, 30);
|
|
EXPECT_EQ(output_target.codec, "h264");
|
|
EXPECT_EQ(output_target.bitrate, 4000000);
|
|
|
|
// 测试LogConfig默认值
|
|
LogConfig log;
|
|
EXPECT_EQ(log.level, "info");
|
|
EXPECT_EQ(log.save_path, "logs/");
|
|
}
|
|
|
|
// 测试配置数据结构的赋值
|
|
TEST(ConfigParserTest, Assignment) {
|
|
// 测试InputSourceConfig赋值
|
|
InputSourceConfig input_source;
|
|
input_source.type = "rtsp";
|
|
input_source.name = "camera1";
|
|
input_source.url = "rtsp://example.com";
|
|
input_source.buffer_size = 50;
|
|
input_source.outputs = {"output1", "output2"};
|
|
|
|
EXPECT_EQ(input_source.type, "rtsp");
|
|
EXPECT_EQ(input_source.name, "camera1");
|
|
EXPECT_EQ(input_source.url, "rtsp://example.com");
|
|
EXPECT_EQ(input_source.buffer_size, 50);
|
|
EXPECT_EQ(input_source.outputs.size(), 2);
|
|
|
|
// 测试完整Pipeline配置
|
|
PipelineConfig config;
|
|
|
|
// 设置输入配置
|
|
config.input.max_batch_size = 8;
|
|
config.input.sources.push_back(input_source);
|
|
|
|
// 设置推理配置
|
|
config.inference.engine_path = "/path/to/model.engine";
|
|
config.inference.precision = "FP32";
|
|
config.inference.threshold.conf = 0.6f;
|
|
config.inference.labels = {"person", "car"};
|
|
config.inference.version = "yolov8";
|
|
|
|
// 设置渲染配置
|
|
RenderConfig::ClassStyle style;
|
|
style.box_color = cv::Scalar(255, 0, 0);
|
|
config.render.class_styles["person"] = style;
|
|
|
|
// 验证设置的值
|
|
EXPECT_EQ(config.input.max_batch_size, 8);
|
|
EXPECT_EQ(config.input.sources.size(), 1);
|
|
EXPECT_EQ(config.inference.engine_path, "/path/to/model.engine");
|
|
EXPECT_EQ(config.inference.precision, "FP32");
|
|
EXPECT_FLOAT_EQ(config.inference.threshold.conf, 0.6f);
|
|
EXPECT_EQ(config.inference.labels.size(), 2);
|
|
EXPECT_EQ(config.inference.version, "yolov8");
|
|
EXPECT_EQ(config.render.class_styles.size(), 1);
|
|
}
|
|
|
|
// 测试渲染样式配置
|
|
TEST(ConfigParserTest, RenderStyleConfig) {
|
|
RenderConfig render;
|
|
|
|
// 设置自定义样式
|
|
RenderConfig::ClassStyle person_style;
|
|
person_style.box_color = cv::Scalar(255, 0, 0); // BGR
|
|
person_style.text_color = cv::Scalar(255, 255, 255);
|
|
person_style.transparency = 0.2f;
|
|
render.class_styles["person"] = person_style;
|
|
|
|
// 验证样式设置
|
|
EXPECT_EQ(render.class_styles.size(), 1);
|
|
EXPECT_EQ(render.class_styles["person"].box_color, cv::Scalar(255, 0, 0));
|
|
EXPECT_EQ(render.class_styles["person"].text_color, cv::Scalar(255, 255, 255));
|
|
EXPECT_FLOAT_EQ(render.class_styles["person"].transparency, 0.2f);
|
|
}
|
|
|
|
// 测试模型标签和版本配置
|
|
TEST(ConfigParserTest, ModelLabelsAndVersion) {
|
|
// 测试ModelConfig的新增字段默认值
|
|
ModelConfig model;
|
|
EXPECT_TRUE(model.labels.empty());
|
|
EXPECT_TRUE(model.version.empty());
|
|
|
|
// 测试标签配置
|
|
model.labels = {"person", "car", "truck"};
|
|
EXPECT_EQ(model.labels.size(), 3);
|
|
EXPECT_EQ(model.labels[0], "person");
|
|
EXPECT_EQ(model.labels[1], "car");
|
|
EXPECT_EQ(model.labels[2], "truck");
|
|
|
|
// 测试版本配置
|
|
model.version = "yolov8";
|
|
EXPECT_EQ(model.version, "yolov8");
|
|
|
|
// 测试完整Pipeline配置中的标签和版本
|
|
PipelineConfig config;
|
|
config.inference.labels = {"person", "car", "truck"};
|
|
config.inference.version = "yolov8";
|
|
|
|
EXPECT_EQ(config.inference.labels.size(), 3);
|
|
EXPECT_EQ(config.inference.version, "yolov8");
|
|
}
|
|
|
|
// 测试渲染样式与标签的匹配
|
|
TEST(ConfigParserTest, RenderStyleLabelMapping) {
|
|
PipelineConfig config;
|
|
|
|
// 设置模型标签
|
|
config.inference.labels = {"person", "car", "truck"};
|
|
|
|
// 设置渲染样式
|
|
RenderConfig::ClassStyle person_style;
|
|
person_style.box_color = cv::Scalar(255, 0, 0); // BGR
|
|
config.render.class_styles["person"] = person_style;
|
|
|
|
RenderConfig::ClassStyle car_style;
|
|
car_style.box_color = cv::Scalar(0, 255, 0);
|
|
config.render.class_styles["car"] = car_style;
|
|
|
|
// 验证标签和样式的匹配
|
|
EXPECT_EQ(config.render.class_styles.count("person"), 1);
|
|
EXPECT_EQ(config.render.class_styles.count("car"), 1);
|
|
EXPECT_EQ(config.render.class_styles["person"].box_color, cv::Scalar(255, 0, 0));
|
|
EXPECT_EQ(config.render.class_styles["car"].box_color, cv::Scalar(0, 255, 0));
|
|
|
|
// 验证未配置样式的标签使用默认样式
|
|
EXPECT_EQ(config.render.class_styles.count("truck"), 0);
|
|
}
|
|
|
|
// 测试输入输出映射配置
|
|
TEST(ConfigParserTest, InputOutputMapping) {
|
|
// 创建配置解析器
|
|
auto parser = createConfigParser();
|
|
|
|
// 创建测试配置文件
|
|
std::ofstream config_file("test_mapping.yaml");
|
|
config_file << R"(
|
|
input:
|
|
sources:
|
|
- type: video
|
|
name: "video1"
|
|
url: "/test/video1.mp4"
|
|
buffer_size: 30
|
|
output_targets: ["output1"]
|
|
- type: rtsp
|
|
name: "camera1"
|
|
url: "rtsp://test/stream1"
|
|
buffer_size: 30
|
|
output_targets: ["output2", "stream1"]
|
|
max_batch_size: 4
|
|
|
|
output:
|
|
targets:
|
|
- type: "video"
|
|
name: "output1"
|
|
path: "/output/video1.mp4"
|
|
fps: 30
|
|
codec: "h264"
|
|
- type: "video"
|
|
name: "output2"
|
|
path: "/output/video2.mp4"
|
|
fps: 30
|
|
codec: "h264"
|
|
- type: "rtsp"
|
|
name: "stream1"
|
|
path: "rtsp://localhost:8554/live"
|
|
fps: 30
|
|
codec: "h264"
|
|
)";
|
|
config_file.close();
|
|
|
|
// 解析配置文件
|
|
ASSERT_TRUE(parser->parse("test_mapping.yaml"));
|
|
ASSERT_TRUE(parser->validate());
|
|
|
|
const auto& config = parser->getConfig();
|
|
|
|
// 验证输入源配置
|
|
ASSERT_EQ(config.input.sources.size(), 2);
|
|
|
|
// 验证第一个输入源的输出映射
|
|
const auto& source1 = config.input.sources[0];
|
|
EXPECT_EQ(source1.name, "video1");
|
|
ASSERT_EQ(source1.outputs.size(), 1);
|
|
EXPECT_EQ(source1.outputs[0], "output1");
|
|
|
|
// 验证第二个输入源的输出映射
|
|
const auto& source2 = config.input.sources[1];
|
|
EXPECT_EQ(source2.name, "camera1");
|
|
ASSERT_EQ(source2.outputs.size(), 2);
|
|
EXPECT_EQ(source2.outputs[0], "output2");
|
|
EXPECT_EQ(source2.outputs[1], "stream1");
|
|
|
|
// 验证输出目标配置
|
|
ASSERT_EQ(config.output.targets.size(), 3);
|
|
|
|
// 清理测试文件
|
|
std::filesystem::remove("test_mapping.yaml");
|
|
}
|
|
|
|
// 测试无效的输出目标映射
|
|
TEST(ConfigParserTest, InvalidOutputMapping) {
|
|
auto parser = createConfigParser();
|
|
|
|
// 创建测试配置文件，包含无效的输出目标
|
|
std::ofstream config_file("invalid_mapping.yaml");
|
|
config_file << R"(
|
|
input:
|
|
sources:
|
|
- type: video
|
|
name: "video1"
|
|
url: "/test/video1.mp4"
|
|
output_targets: ["nonexistent_output"] # 不存在的输出目标
|
|
max_batch_size: 4
|
|
|
|
output:
|
|
targets:
|
|
- type: "video"
|
|
name: "output1"
|
|
path: "/output/video1.mp4"
|
|
fps: 30
|
|
codec: "h264"
|
|
)";
|
|
config_file.close();
|
|
|
|
// 解析配置文件应该成功，但验证应该失败
|
|
ASSERT_TRUE(parser->parse("invalid_mapping.yaml"));
|
|
ASSERT_FALSE(parser->validate()); // 验证应该失败，因为输出目标不存在
|
|
|
|
// 清理测试文件
|
|
std::filesystem::remove("invalid_mapping.yaml");
|
|
}
|
|
|
|
// 测试向后兼容性
|
|
TEST(ConfigParserTest, BackwardCompatibility) {
|
|
auto parser = createConfigParser();
|
|
|
|
// 创建使用旧格式的测试配置文件
|
|
std::ofstream config_file("old_format.yaml");
|
|
config_file << R"(
|
|
input:
|
|
sources:
|
|
- type: video
|
|
name: "video1"
|
|
url: "/test/video1.mp4"
|
|
outputs: ["output1"] # 旧格式使用outputs而不是output_targets
|
|
max_batch_size: 4
|
|
|
|
output:
|
|
targets:
|
|
- type: "video"
|
|
name: "output1"
|
|
path: "/output/video1.mp4"
|
|
fps: 30
|
|
codec: "h264"
|
|
)";
|
|
config_file.close();
|
|
|
|
// 解析和验证应该都成功
|
|
ASSERT_TRUE(parser->parse("old_format.yaml"));
|
|
ASSERT_TRUE(parser->validate());
|
|
|
|
const auto& config = parser->getConfig();
|
|
ASSERT_EQ(config.input.sources.size(), 1);
|
|
ASSERT_EQ(config.input.sources[0].outputs.size(), 1);
|
|
EXPECT_EQ(config.input.sources[0].outputs[0], "output1");
|
|
|
|
// 清理测试文件
|
|
std::filesystem::remove("old_format.yaml");
|
|
}
|