using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using System.Windows;
|
using System.Windows.Media;
|
using System.Windows.Threading;
|
using Aging.Infrastructure.Drivers;
|
using CanSimulator;
|
using log4net;
|
using Plugin.DeviceConfig.Entity;
|
using Plugin.DeviceConfig.Model;
|
using Plugin.DeviceDebug.Entity;
|
using Plugin.DeviceDebug.Model;
|
using Plugin.DeviceDebug.Panels;
|
|
namespace Plugin.IntegrationTest
|
{
|
public partial class MainWindow : Window
|
{
|
private int _passed;
|
private int _failed;
|
private int _totalSteps;
|
private int _currentStep;
|
private string _testDir = string.Empty;
|
private string _logFilePath = string.Empty;
|
private readonly StringBuilder _logBuffer = new();
|
|
// 嵌入的插件实例
|
private Plugin.DeviceConfig.DeviceConfig? _deviceConfigPlugin;
|
private Plugin.DeviceDebug.DeviceDebug? _deviceDebugPlugin;
|
private static readonly ILog _testLog = LogManager.GetLogger("IntegrationTest");
|
|
// CAN 模拟器
|
private CanBusSimulator? _canBus;
|
private CanDebugPanel? _canDebugPanel;
|
|
public MainWindow()
|
{
|
InitializeComponent();
|
}
|
|
private void Window_Loaded(object sender, RoutedEventArgs e)
|
{
|
InitializePlugins();
|
InitializeCanSimulator();
|
}
|
|
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
|
{
|
// 清理 CAN 模拟器
|
_canBus?.Dispose();
|
CanDriverAdapter.ResetAllBuses();
|
|
// 不删除测试目录，保留数据以便重启后恢复
|
// （如需手动重置，使用工具栏中的 "重置数据" 按钮）
|
}
|
|
/// <summary>
|
/// 初始化两个插件并嵌入到对应 Tab 中
|
/// </summary>
|
private void InitializePlugins()
|
{
|
// 使用固定目录保存数据（重启后不丢失）
|
string appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
_testDir = Path.Combine(appData, "PluginIntegrationTest");
|
Directory.CreateDirectory(_testDir);
|
_logFilePath = Path.Combine(_testDir, "test_result.log");
|
|
txtStatus.Text = $"数据目录: {_testDir}";
|
|
try
|
{
|
// 初始化仪器仪表注册插件
|
_deviceConfigPlugin = new Plugin.DeviceConfig.DeviceConfig();
|
_deviceConfigPlugin.SetBaseFolder(_testDir);
|
_deviceConfigPlugin.SetLogger(_testLog);
|
_deviceConfigPlugin.InitFinish();
|
deviceConfigHost.Child = _deviceConfigPlugin;
|
|
// 初始化硬件调试插件
|
_deviceDebugPlugin = new Plugin.DeviceDebug.DeviceDebug();
|
_deviceDebugPlugin.SetBaseFolder(_testDir);
|
_deviceDebugPlugin.SetLogger(_testLog);
|
_deviceDebugPlugin.InitFinish();
|
deviceDebugHost.Child = _deviceDebugPlugin;
|
|
// 预置 CAN 测试设备（方便直接验证驱动与面板）
|
SeedPresetCanDevices();
|
|
// 刷新插件内部列表（需手动调用插件方法）
|
_deviceConfigPlugin.ForceRefreshForTest();
|
_deviceDebugPlugin.ForceRefreshForTest();
|
|
txtStatus.Text = "插件初始化完成 - 可切换 Tab 手动测试";
|
Log("[INFO] 插件初始化成功");
|
Log($"[INFO] 测试目录: {_testDir}");
|
Log("[INFO] DeviceConfig 已嵌入到 '仪器仪表注册' Tab");
|
Log("[INFO] DeviceDebug 已嵌入到 '硬件调试' Tab");
|
Log("[INFO] 预置测试设备: CAN-001, CAN-002 (Transport=Can)");
|
Log("");
|
Log("[TIP] 使用流程:");
|
Log(" 1. 先切换到 '仪器仪表注册' Tab，添加设备、通道、Slot映射等");
|
Log(" 2. 已预置 CAN-001 (CAN_BUS_1:0) 和 CAN-002 (CAN_BUS_1:1) 供测试");
|
Log(" 3. 切换到 '硬件调试' Tab，选择 CAN-001 会自动打开 CAN 面板并连接总线");
|
Log(" 4. 切换到 'CAN 模拟器' Tab 可手动控制总线或另一个节点发送数据");
|
Log(" 5. 可随时点击 '运行自动化测试' 验证核心逻辑");
|
}
|
catch (Exception ex)
|
{
|
txtStatus.Text = $"插件初始化失败: {ex.Message}";
|
Log($"[ERROR] 插件初始化失败: {ex.Message}");
|
Log(ex.StackTrace ?? "");
|
}
|
}
|
|
/// <summary>
|
/// 预置 CAN 测试设备（仅当不存在时插入，避免覆盖用户修改）
|
/// </summary>
|
private void SeedPresetCanDevices()
|
{
|
try
|
{
|
var model = new DeviceConfigModel();
|
string dbPath = Path.Combine(_testDir, "data.db");
|
model.InitDatabase(dbPath);
|
|
int inserted = 0;
|
|
// CAN-001
|
if (model.GetDeviceById("CAN-001") == null)
|
{
|
model.SaveDevice(new DeviceDefinition
|
{
|
DeviceId = "CAN-001",
|
Kind = DeviceKind.CanDevice,
|
DriverType = "CAN",
|
Transport = TransportType.Can,
|
Endpoint = "CAN_BUS_1:0",
|
EffectiveVersion = "V1.0"
|
});
|
inserted++;
|
}
|
|
// CAN-002
|
if (model.GetDeviceById("CAN-002") == null)
|
{
|
model.SaveDevice(new DeviceDefinition
|
{
|
DeviceId = "CAN-002",
|
Kind = DeviceKind.CanDevice,
|
DriverType = "CAN",
|
Transport = TransportType.Can,
|
Endpoint = "CAN_BUS_1:1",
|
EffectiveVersion = "V1.0"
|
});
|
inserted++;
|
}
|
|
Log(inserted > 0
|
? $"[INFO] 预置 CAN 设备: 新增 {inserted} 个"
|
: "[INFO] 预置 CAN 设备已存在，未覆盖");
|
}
|
catch (Exception ex)
|
{
|
Log($"[WARN] 预置 CAN 设备失败: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 重置测试数据（删除本地目录中的 db 文件）
|
/// </summary>
|
private void ResetTestData()
|
{
|
try
|
{
|
if (MessageBox.Show("确定要删除本地保存的设备数据吗？\n此操作不可恢复！",
|
"确认重置", MessageBoxButton.YesNo, MessageBoxImage.Warning) != MessageBoxResult.Yes)
|
{
|
return;
|
}
|
|
// 释放插件后删除数据
|
_deviceConfigPlugin = null;
|
_deviceDebugPlugin = null;
|
|
foreach (var file in Directory.GetFiles(_testDir, "*.db", SearchOption.AllDirectories))
|
{
|
try { File.Delete(file); } catch { }
|
}
|
|
GC.Collect();
|
GC.WaitForPendingFinalizers();
|
|
MessageBox.Show("数据已重置，请重新启动程序。", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
|
}
|
catch (Exception ex)
|
{
|
MessageBox.Show($"重置失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
|
}
|
}
|
|
private void BtnClear_Click(object sender, RoutedEventArgs e)
|
{
|
txtLog.Clear();
|
txtSummary.Text = "就绪 - 请切换到对应 Tab 进行手动测试";
|
txtPassed.Text = "";
|
txtFailed.Text = "";
|
progressBar.Value = 0;
|
_passed = 0;
|
_failed = 0;
|
_currentStep = 0;
|
btnRun.IsEnabled = true;
|
}
|
|
private void BtnReset_Click(object sender, RoutedEventArgs e)
|
{
|
ResetTestData();
|
}
|
|
private async void BtnRun_Click(object sender, RoutedEventArgs e)
|
{
|
btnRun.IsEnabled = false;
|
txtLog.Clear();
|
_passed = 0;
|
_failed = 0;
|
_currentStep = 0;
|
|
_totalSteps = CountTestSteps();
|
UpdateProgress();
|
|
Log("========================================");
|
Log(" 仪器仪表注册 & 硬件调试 集成测试");
|
Log($" 时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
|
Log("========================================");
|
Log("");
|
|
// 为自动化测试创建独立的数据库目录
|
string autoTestDir = Path.Combine(_testDir, "auto_test_" + Guid.NewGuid().ToString("N").Substring(0, 8));
|
Directory.CreateDirectory(autoTestDir);
|
|
await Task.Run(() => RunAllTests(autoTestDir));
|
|
Log("");
|
Log("========================================");
|
string result = _failed == 0 ? "全部通过 ✓" : $"有 {_failed} 项失败 ✗";
|
Log($" 测试结果: {result}");
|
Log($" 通过: {_passed} 失败: {_failed} 总计: {_passed + _failed}");
|
Log("========================================");
|
|
Dispatcher.Invoke(() =>
|
{
|
txtSummary.Text = _failed == 0 ? "✓ 自动化测试全部通过" : $"✗ 有 {_failed} 项测试失败";
|
txtSummary.Foreground = _failed == 0
|
? System.Windows.Media.Brushes.Green
|
: System.Windows.Media.Brushes.Red;
|
txtPassed.Text = $"通过: {_passed}";
|
txtFailed.Text = $"失败: {_failed}";
|
btnRun.IsEnabled = true;
|
|
// 复制日志到输出目录
|
try
|
{
|
string appDir = AppDomain.CurrentDomain.BaseDirectory;
|
string copyPath = Path.Combine(appDir, "test_result.log");
|
File.Copy(_logFilePath, copyPath, overwrite: true);
|
}
|
catch { }
|
});
|
}
|
|
private int CountTestSteps() => 22;
|
|
private void RunAllTests(string testDir)
|
{
|
string configDbPath = Path.Combine(testDir, "device_config.db");
|
string debugDbPath = Path.Combine(testDir, "device_debug.db");
|
|
// ===== 第一部分：仪器仪表注册 =====
|
RunSection("第一部分：仪器仪表注册 (DeviceConfig)");
|
|
var configModel = TestInit("初始化设备配置数据库", () =>
|
{
|
var model = new DeviceConfigModel();
|
model.InitDatabase(configDbPath);
|
return model;
|
});
|
|
if (configModel == null)
|
{
|
SkipRemainingSection(9, "DeviceConfig 数据库初始化失败");
|
}
|
else
|
{
|
var device = TestInit("创建设备定义（电源设备）", () =>
|
{
|
var dev = new DeviceDefinition
|
{
|
DeviceId = "PS-001",
|
Kind = DeviceKind.PowerSupply,
|
DriverType = "SCPI",
|
Transport = TransportType.Tcp,
|
Endpoint = "192.168.1.100:5025",
|
EffectiveVersion = "V1.0",
|
CreatedAt = DateTime.Now,
|
UpdatedAt = DateTime.Now
|
};
|
configModel.SaveDevice(dev);
|
return dev;
|
});
|
|
TestStep("读取设备定义并验证", () =>
|
{
|
var read = configModel.GetDeviceById("PS-001");
|
Assert(read != null, "设备应存在");
|
Assert(read!.Kind == DeviceKind.PowerSupply, "种类应为PowerSupply");
|
Assert(read.Transport == TransportType.Tcp, "传输方式应为Tcp");
|
Assert(read.Endpoint == "192.168.1.100:5025", "端点地址应匹配");
|
});
|
|
TestStep("更新设备定义", () =>
|
{
|
Assert(device != null, "设备对象不应为空");
|
device!.Endpoint = "192.168.1.200:5025";
|
device.EffectiveVersion = "V2.0";
|
configModel.SaveDevice(device);
|
var updated = configModel.GetDeviceById("PS-001");
|
Assert(updated!.Endpoint == "192.168.1.200:5025", "端点应已更新");
|
Assert(updated.EffectiveVersion == "V2.0", "版本应已更新");
|
});
|
|
TestStep("添加设备通道", () =>
|
{
|
for (int i = 1; i <= 4; i++)
|
{
|
var ch = new DeviceChannel
|
{
|
DeviceId = "PS-001",
|
ChannelId = i,
|
Capability = i <= 2 ? "Voltage" : "Current",
|
MaxVoltage = 30.0,
|
MaxCurrent = 5.0,
|
Limits = $"{{\"min_v\":0,\"max_v\":30,\"min_i\":0,\"max_i\":5}}",
|
SessionKey = ""
|
};
|
configModel.SaveChannel(ch);
|
}
|
var channels = configModel.GetChannelsByDevice("PS-001");
|
Assert(channels.Count == 4, $"应有4个通道，实际{channels.Count}个");
|
});
|
|
TestStep("添加Slot映射", () =>
|
{
|
var mapping = new SlotDeviceMapping
|
{
|
SlotId = "SLOT-01",
|
Capability = "Power",
|
Version = "V2.0",
|
DeviceId = "PS-001",
|
ChannelId = 1,
|
MappingVersion = "MV-001"
|
};
|
configModel.SaveSlotMapping(mapping);
|
var mappings = configModel.GetSlotMappings();
|
Assert(mappings.Count == 1, "应有1条Slot映射");
|
Assert(mappings[0].DeviceId == "PS-001", "映射设备ID应匹配");
|
});
|
|
TestStep("创建配置版本", () =>
|
{
|
var ver = new DeviceConfigVersion
|
{
|
VersionId = "VER-001",
|
Status = VersionStatus.Draft,
|
Hash = configModel.ComputeConfigHash(),
|
Author = "TestUser",
|
Timestamp = DateTime.Now,
|
DiffDescription = "初始配置"
|
};
|
configModel.SaveConfigVersion(ver);
|
var versions = configModel.GetConfigVersions();
|
Assert(versions.Count == 1, "应有1个版本");
|
Assert(versions[0].Status == VersionStatus.Draft, "版本状态应为Draft");
|
Assert(!string.IsNullOrEmpty(versions[0].Hash), "哈希不应为空");
|
});
|
|
TestStep("冲突检测（应无冲突）", () =>
|
{
|
var conflicts = configModel.DetectConflicts();
|
Assert(conflicts.Count == 0, $"不应有冲突，实际: {string.Join("; ", conflicts)}");
|
});
|
|
TestStep("添加第二个设备并检测IP冲突", () =>
|
{
|
var dev2 = new DeviceDefinition
|
{
|
DeviceId = "PS-002",
|
Kind = DeviceKind.PowerSupply,
|
DriverType = "SCPI",
|
Transport = TransportType.Tcp,
|
Endpoint = "192.168.1.200:5025",
|
EffectiveVersion = "V1.0",
|
CreatedAt = DateTime.Now,
|
UpdatedAt = DateTime.Now
|
};
|
configModel.SaveDevice(dev2);
|
|
var dev3 = new DeviceDefinition
|
{
|
DeviceId = "PS-003",
|
Kind = DeviceKind.PowerSupply,
|
DriverType = "ModbusTCP",
|
Transport = TransportType.Tcp,
|
Endpoint = "192.168.1.200:5025",
|
EffectiveVersion = "V1.0",
|
CreatedAt = DateTime.Now,
|
UpdatedAt = DateTime.Now
|
};
|
configModel.SaveDevice(dev3);
|
|
var conflicts = configModel.DetectConflicts();
|
Assert(conflicts.Count > 0, "应检测到IP冲突");
|
Log($" [冲突] {conflicts[0]}");
|
});
|
|
TestStep("删除设备和清理", () =>
|
{
|
configModel.DeleteDevice("PS-003");
|
configModel.DeleteChannel("PS-001", 4);
|
var allDevices = configModel.GetAllDevices();
|
Assert(allDevices.Count == 2, $"删除后应有2个设备，实际{allDevices.Count}");
|
var channels = configModel.GetChannelsByDevice("PS-001");
|
Assert(channels.Count == 3, $"删除通道后应有3个，实际{channels.Count}");
|
});
|
}
|
|
Log("");
|
|
// ===== 第二部分：硬件调试 =====
|
RunSection("第二部分：硬件调试 (DeviceDebug)");
|
|
var debugModel = TestInit("初始化调试数据库", () =>
|
{
|
var model = new DeviceDebugModel();
|
model.InitDatabase(debugDbPath);
|
return model;
|
});
|
|
DebugSessionManager? sessionMgr = null;
|
if (debugModel == null)
|
{
|
SkipRemainingSection(8, "DeviceDebug 数据库初始化失败");
|
}
|
else
|
{
|
sessionMgr = TestInit("创建会话管理器", () =>
|
{
|
return new DebugSessionManager(debugModel, resourceManager: null);
|
});
|
|
if (sessionMgr == null)
|
{
|
SkipRemainingSection(7, "会话管理器创建失败");
|
}
|
else
|
{
|
string? sessionId = null;
|
TestStep("打开调试会话（ReadOnly）", () =>
|
{
|
var session = sessionMgr.OpenSession("PS-001", "OP001", "张工", "V2.0");
|
sessionId = session.SessionId;
|
Assert(!string.IsNullOrEmpty(sessionId), "会话ID不应为空");
|
Assert(session.State == DebugSessionState.ReadOnly, "初始状态应为ReadOnly");
|
Assert(session.DeviceId == "PS-001", "设备ID应匹配");
|
Log($" 会话ID: {sessionId}");
|
});
|
|
if (sessionId == null)
|
{
|
SkipRemainingSection(6, "打开会话失败");
|
}
|
else
|
{
|
TestStep("请求维护模式（ReadOnly → AcquiringMaintenance）", () =>
|
{
|
bool result = sessionMgr.RequestMaintenance(sessionId!);
|
Assert(result, "请求维护应成功");
|
var state = sessionMgr.GetSessionState(sessionId!);
|
Assert(state == DebugSessionState.AcquiringMaintenance, $"状态应为AcquiringMaintenance，实际{state}");
|
});
|
|
TestStep("激活维护模式（AcquiringMaintenance → MaintenanceActive）", () =>
|
{
|
sessionMgr.ActivateMaintenance(sessionId!);
|
var state = sessionMgr.GetSessionState(sessionId!);
|
Assert(state == DebugSessionState.MaintenanceActive, $"状态应为MaintenanceActive，实际{state}");
|
});
|
|
TestStep("验证命令执行权限", () =>
|
{
|
var cmd = new PowerSetCommand { Voltage = 12.5, CurrentLimit = 3.0, Output = true };
|
bool allowed = sessionMgr.ValidateCommand(sessionId!, cmd);
|
Assert(allowed, "MaintenanceActive状态下应允许命令执行");
|
|
var readOnlySession = sessionMgr.OpenSession("PS-002", "OP002", "李工", "V1.0");
|
bool readOnlyAllowed = sessionMgr.ValidateCommand(readOnlySession.SessionId, cmd);
|
Assert(!readOnlyAllowed, "ReadOnly状态下应拒绝命令执行");
|
});
|
|
TestStep("记录调试操作审计", () =>
|
{
|
var op = new DebugOperation
|
{
|
SessionId = sessionId!,
|
CommandType = "PowerSet",
|
Parameters = "{\"voltage\":12.5,\"current\":3.0,\"output\":true}",
|
Outcome = "Success",
|
DeviceReadback = "V=12.48,I=2.99",
|
ErrorCode = "",
|
ErrorMessage = ""
|
};
|
debugModel.RecordOperation(op);
|
|
var ops = debugModel.GetOperationsBySession(sessionId!);
|
Assert(ops.Count == 1, $"应有1条操作记录，实际{ops.Count}");
|
Assert(ops[0].CommandType == "PowerSet", "命令类型应匹配");
|
Assert(ops[0].Outcome == "Success", "结果应为Success");
|
});
|
|
TestStep("关闭会话（MaintenanceActive → Closing → Closed）", () =>
|
{
|
sessionMgr.CloseSession(sessionId!);
|
var state = sessionMgr.GetSessionState(sessionId!);
|
Assert(state == DebugSessionState.Closed, $"状态应为Closed，实际{state}");
|
|
var session = debugModel.GetSession(sessionId!);
|
Assert(session != null, "会话记录应仍存在");
|
Assert(session!.ClosedAt.HasValue, "关闭时间应已设置");
|
});
|
|
TestStep("故障和恢复测试", () =>
|
{
|
var faultSession = sessionMgr.OpenSession("PS-001", "OP001", "张工", "V2.0");
|
string faultId = faultSession.SessionId;
|
sessionMgr.RequestMaintenance(faultId);
|
sessionMgr.ActivateMaintenance(faultId);
|
|
sessionMgr.FaultSession(faultId, "通信超时");
|
var state = sessionMgr.GetSessionState(faultId);
|
Assert(state == DebugSessionState.Faulted, $"状态应为Faulted，实际{state}");
|
|
sessionMgr.MarkRecoveryRequired(faultId);
|
state = sessionMgr.GetSessionState(faultId);
|
Assert(state == DebugSessionState.RecoveryRequired, $"状态应为RecoveryRequired，实际{state}");
|
});
|
}
|
}
|
}
|
|
Log("");
|
|
// ===== 第三部分：跨模块联动验证 =====
|
RunSection("第三部分：跨模块联动验证");
|
|
if (configModel == null || debugModel == null)
|
{
|
SkipRemainingSection(4, "前置模块初始化失败，跳过联动测试");
|
}
|
else
|
{
|
TestStep("设备配置 → 调试会话数据一致性", () =>
|
{
|
var configDevice = configModel.GetDeviceById("PS-001");
|
Assert(configDevice != null, "配置中应存在PS-001");
|
|
var activeSessions = debugModel.GetActiveSessionsByDevice("PS-001");
|
Assert(activeSessions.Count > 0, "PS-001应有活跃会话记录");
|
Assert(activeSessions.All(s => s.DeviceId == "PS-001"), "所有会话应引用PS-001");
|
});
|
|
TestStep("配置版本哈希一致性", () =>
|
{
|
var currentHash = configModel.ComputeConfigHash();
|
var versions = configModel.GetConfigVersions();
|
Assert(versions.Count > 0, "应有版本记录");
|
|
string originalHash = versions[0].Hash;
|
Log($" 原始哈希: {originalHash.Substring(0, 16)}...");
|
Log($" 当前哈希: {currentHash.Substring(0, 16)}...");
|
Log($" 哈希变化: {(originalHash != currentHash ? "是（配置已更新）" : "否")}");
|
Assert(true, "哈希计算流程正常");
|
});
|
|
TestStep("操作审计完整性验证", () =>
|
{
|
var allSessions = debugModel.GetAllSessions();
|
int totalOps = 0;
|
foreach (var s in allSessions)
|
{
|
var ops = debugModel.GetOperationsBySession(s.SessionId);
|
totalOps += ops.Count;
|
}
|
Assert(totalOps > 0, $"应有操作审计记录，实际{totalOps}条");
|
Log($" 总会话数: {allSessions.Count}, 总操作记录: {totalOps}");
|
});
|
|
TestStep("设备组模板功能验证", () =>
|
{
|
var template = new DeviceGroupTemplate
|
{
|
TemplateId = "TPL-001",
|
DeviceType = "PowerSupply",
|
DriverType = "SCPI",
|
Transport = "Tcp",
|
DeviceCount = 4,
|
ChannelsPerDevice = 4,
|
AddressRule = "192.168.1.{0}",
|
SlotStart = 1
|
};
|
configModel.SaveGroupTemplate(template);
|
var templates = configModel.GetGroupTemplates();
|
Assert(templates.Count == 1, "应有1个模板");
|
Assert(templates[0].DeviceCount == 4, "设备数量应为4");
|
});
|
}
|
}
|
|
#region CAN 模拟器
|
|
/// <summary>
|
/// 初始化 CAN 模拟器
|
/// </summary>
|
private void InitializeCanSimulator()
|
{
|
try
|
{
|
// 创建 CAN 调试面板并嵌入到 Tab 中
|
_canDebugPanel = new CanDebugPanel();
|
canSimulatorHost.Child = _canDebugPanel;
|
|
Log("[INFO] CAN 模拟器已嵌入到 'CAN 模拟器' Tab");
|
}
|
catch (Exception ex)
|
{
|
Log($"[ERROR] CAN 模拟器初始化失败: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 启动总线按钮点击
|
/// </summary>
|
private void CanStartBtn_Click(object sender, RoutedEventArgs e)
|
{
|
try
|
{
|
string busName = canBusNameInput.Text.Trim();
|
if (string.IsNullOrEmpty(busName))
|
{
|
MessageBox.Show("请输入总线名称", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
|
return;
|
}
|
|
// 通过 DriverFactory 创建 CAN 驱动来启动总线
|
var driver = DriverFactory.CreateDriver("CAN_SIM_0", "CAN", $"{busName}:0");
|
driver.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
|
|
// 获取总线实例
|
var buses = CanDriverAdapter.GetAllBuses();
|
if (buses.TryGetValue(busName, out var bus))
|
{
|
_canBus = bus;
|
bus.Start();
|
|
// 更新 UI
|
canBusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
|
canBusStatusText.Text = $"运行中 ({busName})";
|
canStartBtn.IsEnabled = false;
|
canStopBtn.IsEnabled = true;
|
|
Log($"[CAN] 总线 {busName} 已启动");
|
}
|
}
|
catch (Exception ex)
|
{
|
Log($"[CAN] 启动总线失败: {ex.Message}");
|
MessageBox.Show($"启动失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
|
}
|
}
|
|
/// <summary>
|
/// 停止总线按钮点击
|
/// </summary>
|
private void CanStopBtn_Click(object sender, RoutedEventArgs e)
|
{
|
try
|
{
|
_canBus?.Stop();
|
|
// 更新 UI
|
canBusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
|
canBusStatusText.Text = "已停止";
|
canStartBtn.IsEnabled = true;
|
canStopBtn.IsEnabled = false;
|
|
Log("[CAN] 总线已停止");
|
}
|
catch (Exception ex)
|
{
|
Log($"[CAN] 停止总线失败: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 重置所有按钮点击
|
/// </summary>
|
private void CanResetBtn_Click(object sender, RoutedEventArgs e)
|
{
|
try
|
{
|
CanDriverAdapter.ResetAllBuses();
|
_canBus = null;
|
|
// 更新 UI
|
canBusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
|
canBusStatusText.Text = "未启动";
|
canStartBtn.IsEnabled = true;
|
canStopBtn.IsEnabled = false;
|
|
Log("[CAN] 所有总线已重置");
|
}
|
catch (Exception ex)
|
{
|
Log($"[CAN] 重置失败: {ex.Message}");
|
}
|
}
|
|
#endregion
|
|
#region 测试辅助方法
|
|
private T? TestInit<T>(string name, Func<T> action) where T : class
|
{
|
_currentStep++;
|
UpdateProgress();
|
try
|
{
|
var result = action();
|
_passed++;
|
LogStep("PASS", name);
|
return result;
|
}
|
catch (Exception ex)
|
{
|
_failed++;
|
LogStep("FAIL", name, ex.Message);
|
return default;
|
}
|
}
|
|
private void TestStep(string name, Action action)
|
{
|
_currentStep++;
|
UpdateProgress();
|
try
|
{
|
action();
|
_passed++;
|
LogStep("PASS", name);
|
}
|
catch (Exception ex)
|
{
|
_failed++;
|
LogStep("FAIL", name, ex.Message);
|
}
|
}
|
|
private void Assert(bool condition, string message)
|
{
|
if (!condition)
|
throw new Exception($"断言失败: {message}");
|
}
|
|
private void RunSection(string title)
|
{
|
Log($"--- {title} ---");
|
Log("");
|
}
|
|
private void SkipRemainingSection(int count, string reason)
|
{
|
for (int i = 0; i < count; i++)
|
{
|
_currentStep++;
|
_failed++;
|
UpdateProgress();
|
LogStep("FAIL", $"[SKIP] 依赖失败: {reason}");
|
}
|
}
|
|
private void LogStep(string status, string name, string? error = null)
|
{
|
string line = status == "PASS"
|
? $" [PASS] {name}"
|
: $" [FAIL] {name} → {error}";
|
Log(line);
|
}
|
|
private void Log(string message)
|
{
|
_logBuffer.AppendLine(message);
|
Dispatcher.Invoke(() =>
|
{
|
txtLog.AppendText(message + Environment.NewLine);
|
txtLog.ScrollToEnd();
|
});
|
if (!string.IsNullOrEmpty(_logFilePath))
|
{
|
try { File.AppendAllText(_logFilePath, message + Environment.NewLine); }
|
catch { }
|
}
|
}
|
|
private void UpdateProgress()
|
{
|
Dispatcher.Invoke(() =>
|
{
|
if (_totalSteps > 0)
|
{
|
double pct = (_currentStep * 100.0) / _totalSteps;
|
progressBar.Value = Math.Min(pct, 100);
|
}
|
});
|
}
|
|
#endregion
|
}
|
}
|
