Skip to content

S
sparrowzz
Commit 45eed44f by dongshufeng
Options

remove tests

parent e6bcba7b
正在显示 包含 4 行增加 和 3118 行删除
eig-aoe/src/aoe/mod.rs
......@@ -391,1179 +391,3 @@ pub struct Aoe {
// 上面定义变量相互之间的关系
pub(crate) expr_graph: Option<ExprGraph>,
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use async_channel::{bounded, Receiver, Sender};
use log::debug;
use eig_domain::*;
use eig_domain::utils::get_timestamp;
use crate::aoe::*;
use crate::aoe::dispatcher::Dispatcher;
use crate::aoe::parse::{from_file2, initial_aoe_points};
#[tokio::test]
async fn test_fire_alarm_aoe() {
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
let name = "fire alarm".to_string();
let mut aoe = Aoe::new(1, name, TriggerType::EventDrive);
let start = EventNode {
id: 1,
aoe_id: 1,
name: "火警信号".to_string(),
node_type: NodeType::ConditionNode,
expr: "FIRE_ALARM > 0".parse().unwrap(),
timeout: 0,
};
let end = EventNode {
id: 2,
aoe_id: 1,
name: "结束".to_string(),
node_type: NodeType::ConditionNode,
expr: "PCS_STOP == 1 && PCS_P_1 < 1e-4 && PCS_P_2 < 1e-4 && PCS_P_3 < 1e-4 "
.parse()
.unwrap(),
timeout: 5000,
};
aoe.model.events.push(start);
aoe.model.events.push(end);
let set_points = SetPoints {
discrete_id: vec!["2".to_string()],
discrete_v: vec!["1".parse().unwrap()],
analog_id: vec!["3".to_string(), "4".to_string(), "5".to_string()],
analog_v: vec![
"0.0".parse().unwrap(),
"0.0".parse().unwrap(),
"0.0".parse().unwrap(),
],
};
aoe.model.actions.push(ActionEdge {
aoe_id: 1,
name: "shut down system".to_string(),
source_node: 1,
target_node: 2,
failure_mode: FailureMode::Default,
action: EigAction::SetPoints(set_points),
});
let mut current_mvs: HashMap<u64, Measurement> = HashMap::new();
let mut alias_to_id: HashMap<String, u64> = HashMap::new();
current_mvs.insert(1, init_discrete_point(1, 1));
current_mvs.insert(2, init_discrete_point(2, 0));
current_mvs.insert(3, init_analog_point(3, 10.0));
current_mvs.insert(4, init_analog_point(4, 10.0));
current_mvs.insert(5, init_analog_point(5, 10.0));
current_mvs.get_mut(&1).unwrap().alias_id = "FIRE_ALARM".to_string();
current_mvs.get_mut(&2).unwrap().alias_id = "PCS_STOP".to_string();
current_mvs.get_mut(&3).unwrap().alias_id = "PCS_P_1".to_string();
current_mvs.get_mut(&4).unwrap().alias_id = "PCS_P_2".to_string();
current_mvs.get_mut(&5).unwrap().alias_id = "PCS_P_3".to_string();
for (id, m) in &current_mvs {
alias_to_id.insert(m.alias_id.clone(), *id);
}
// 结束构建AOE
let check_result = aoe.finish_and_check();
// 初始化测量点
aoe.initial_points(&current_mvs, &alias_to_id);
assert_eq!(check_result, None);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
// 启动AOE
assert!(aoe.should_start());
aoe.start().await;
let m = aoe.measure_buf.get_mv(&2);
assert!(m.is_some());
assert_eq!(1, m.unwrap().discrete_value);
let m = aoe.measure_buf.get_mv(&3);
assert!(m.is_some());
assert_eq!(0.0, m.unwrap().analog_value);
let m = aoe.measure_buf.get_mv(&4);
assert!(m.is_some());
assert_eq!(0.0, m.unwrap().analog_value);
let m = aoe.measure_buf.get_mv(&5);
assert!(m.is_some());
assert_eq!(0.0, m.unwrap().analog_value);
}
#[tokio::test]
async fn test_aoe_file1() {
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
let r = from_file2("tests/test_zq/aoe-test1.csv", false);
assert!(r.is_ok());
let (points, _) = from_csv2("tests/test_zq/points-zq.csv", false).unwrap();
let mut aoes = r.unwrap();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let job = tokio::spawn(async move {
let mut count = 0;
loop {
match rx.recv().await {
Ok(r) => {
println!("aoe finish: {}", r.aoe_id);
if r.aoe_id == 1 || r.aoe_id == 2 {
assert_eq!(2, r.event_result.len());
assert_eq!(1, r.action_result.len());
}
if r.aoe_id == 3 {
assert_eq!(3, r.event_result.len());
}
count += 1;
}
Err(_) => {
break;
}
}
if count == 4 {
break;
}
}
});
dispatcher.schedule(aoes);
job.await.unwrap();
dispatcher.shutdown().await;
// tokio::time::sleep(Duration::from_secs(5)).await;
}
#[tokio::test]
async fn test_aoe_file_heater() {
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
let r = from_file2("tests/test_househeat/aoe-househeat_test.csv", false);
println!("Aoe parse result : {:?}", r);
assert!(r.is_ok());
let (points, _) = from_csv2("tests/test_househeat/points-aoe-househeat.csv", false).unwrap();
let mut aoes = r.unwrap();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let job = tokio::spawn(async move {
let mut count = 0;
loop {
match rx.recv().await {
Ok(r) => {
println!("aoe finish: {}", r.aoe_id);
assert_eq!(4, r.event_result.len());
assert_eq!(3, r.action_result.len());
count += 1;
}
Err(_) => {
break;
}
}
if count == 4 {
break;
}
}
});
dispatcher.schedule(aoes);
job.await.unwrap();
dispatcher.shutdown().await;
}
#[tokio::test]
async fn test_aoe_get_time() {
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
do_aoe_get_time("tests/test_time/aoe-time-test.csv").await;
}
#[tokio::test]
async fn test_aoe_get_time2() {
do_aoe_get_time("tests/test_time/aoe-time-test2.csv").await;
}
async fn do_aoe_get_time(aoe_file: &str) {
let r = from_file2(aoe_file, false);
println!("Aoe parse result : {:?}", r);
assert!(r.is_ok());
let (points, _) = from_csv2("tests/test_time/points-timetest.csv", false).unwrap();
// 设为离散点
assert!(!points.get(&400133025).unwrap().is_discrete);
assert!(!points.get(&400133026).unwrap().is_discrete);
let mut alias: HashMap<String, u64> = HashMap::with_capacity(points.len());
// 先形成别名的map
for m in points.values() {
if !m.alias_id.is_empty() {
let key = m.alias_id.clone();
alias.insert(key, m.point_id);
}
}
let mut aoes = r.unwrap();
let set_measure_tx = aoes[0].measure_sender();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let job = tokio::spawn(async move {
let mut count = 0;
loop {
match rx.recv().await {
Ok(r) => {
println!("aoe finish: {}", r.aoe_id);
assert_eq!(2, r.event_result.len());
assert_eq!(1, r.action_result.len());
count += 1;
}
Err(_) => {
break;
}
}
if count == 1 {
break;
}
}
});
dispatcher.schedule(aoes);
// 设置初始值
set_points("", "pcs_304:18;pcs_305:47", &alias, &set_measure_tx).await;
job.await.unwrap();
dispatcher.shutdown().await;
}
#[cfg(feature = "milp")]
#[tokio::test]
async fn test_aoe_file2() {
use log::debug;
let log_env = env_logger::Env::default().default_filter_or("trace");
env_logger::Builder::from_env(log_env).init();
// 8 PCS start
let agc_mode1 = "EMS_MODE_AGC_POINT:1";
let bms_status_str1 = "BAMS1_WORK_STATUS_POINT:1;BAMS2_WORK_STATUS_POINT:1;BAMS3_WORK_STATUS_POINT:1;BAMS4_WORK_STATUS_POINT:1;BAMS5_WORK_STATUS_POINT:1;BAMS6_WORK_STATUS_POINT:1;BAMS7_WORK_STATUS_POINT:1;BAMS8_WORK_STATUS_POINT:1";
// Cross-sectional data set 1 (RESULT: Discharge strategy 1)
let mileage_str1 = "BAMS1_MILEAGE_TOTAL_POINT:0;BAMS2_MILEAGE_TOTAL_POINT:0;BAMS3_MILEAGE_TOTAL_POINT:0;BAMS4_MILEAGE_TOTAL_POINT:0;BAMS5_MILEAGE_TOTAL_POINT:0;BAMS6_MILEAGE_TOTAL_POINT:0;BAMS7_MILEAGE_TOTAL_POINT:0;BAMS8_MILEAGE_TOTAL_POINT:0";
let rated_mileage_str1 = "BAMS1_RATEDMILEAGE:1000;BAMS2_RATEDMILEAGE:1000;BAMS3_RATEDMILEAGE:1000;BAMS4_RATEDMILEAGE:1000;BAMS5_RATEDMILEAGE:1000;BAMS6_RATEDMILEAGE:1000;BAMS7_RATEDMILEAGE:1000;BAMS8_RATEDMILEAGE:1000";
let bms_capacity_str1 = "BAMS1_CAPACITY:1000;BAMS2_CAPACITY:1000;BAMS3_CAPACITY:1000;BAMS4_CAPACITY:1000;BAMS5_CAPACITY:1000;BAMS6_CAPACITY:1000;BAMS7_CAPACITY:1000;BAMS8_CAPACITY:1000";
let max_charging_power_str1 = "BAMS1_CMAX_POINT:1500;BAMS2_CMAX_POINT:1500;BAMS3_CMAX_POINT:1500;BAMS4_CMAX_POINT:1500;BAMS5_CMAX_POINT:1500;BAMS6_CMAX_POINT:1500;BAMS7_CMAX_POINT:1500;BAMS8_CMAX_POINT:1500";
let max_discharging_power_str1 = "BAMS1_DMAX_POINT:1500;BAMS2_DMAX_POINT:1500;BAMS3_DMAX_POINT:1500;BAMS4_DMAX_POINT:1500;BAMS5_DMAX_POINT:1500;BAMS6_DMAX_POINT:1500;BAMS7_DMAX_POINT:1500;BAMS8_DMAX_POINT:1500";
let soc_str1 = "BAMS1_SOC_POINT:70;BAMS2_SOC_POINT:70;BAMS3_SOC_POINT:60;BAMS4_SOC_POINT:70;BAMS5_SOC_POINT:70;BAMS6_SOC_POINT:20;BAMS7_SOC_POINT:70;BAMS8_SOC_POINT:70";
let bms_p1 = "BAMS1_P_POINT:0;BAMS2_P_POINT:0;BAMS3_P_POINT:0;BAMS4_P_POINT:0;BAMS5_P_POINT:0;BAMS6_P_POINT:0;BAMS7_P_POINT:0;BAMS8_P_POINT:0";
let total_power_str1 = "GEN_TOTAL_P_POINT:2400";
let dstr1 = bms_status_str1.to_string() + ";" + agc_mode1;
let astr1 = soc_str1.to_string()
+ ";"
+ mileage_str1
+ ";"
+ rated_mileage_str1
+ ";"
+ bms_capacity_str1
+ ";"
+ max_charging_power_str1
+ ";"
+ max_discharging_power_str1
+ ";"
+ total_power_str1
+ ";"
+ bms_p1;
// Cross-sectional data set 2 (RESULT: Charge strategy 1)
let soc_str2 = "BAMS1_SOC_POINT:30;BAMS2_SOC_POINT:30;BAMS3_SOC_POINT:30;BAMS4_SOC_POINT:20;BAMS5_SOC_POINT:30;BAMS6_SOC_POINT:30;BAMS7_SOC_POINT:30;BAMS8_SOC_POINT:70";
let total_power_str2 = "GEN_TOTAL_P_POINT:-3000";
let dstr2 = bms_status_str1.to_string() + ";" + agc_mode1;
let astr2 = soc_str2.to_string()
+ ";"
+ mileage_str1
+ ";"
+ rated_mileage_str1
+ ";"
+ bms_capacity_str1
+ ";"
+ max_charging_power_str1
+ ";"
+ max_discharging_power_str1
+ ";"
+ total_power_str2
+ ";"
+ bms_p1;
// Cross-sectional data set 3 (RESULT: Discharge strategy 2)
let soc_str3 = "BAMS1_SOC_POINT:50;BAMS2_SOC_POINT:70;BAMS3_SOC_POINT:60;BAMS4_SOC_POINT:50;BAMS5_SOC_POINT:50;BAMS6_SOC_POINT:50;BAMS7_SOC_POINT:50;BAMS8_SOC_POINT:50";
let total_power_str3 = "GEN_TOTAL_P_POINT:4000";
let dstr3 = bms_status_str1.to_string() + ";" + agc_mode1;
let astr3 = soc_str3.to_string()
+ ";"
+ mileage_str1
+ ";"
+ rated_mileage_str1
+ ";"
+ bms_capacity_str1
+ ";"
+ max_charging_power_str1
+ ";"
+ max_discharging_power_str1
+ ";"
+ total_power_str3
+ ";"
+ bms_p1;
// Cross-sectional data set 4 (RESULT: Charge strategy 2)
let soc_str4 = "BAMS1_SOC_POINT:30;BAMS2_SOC_POINT:40;BAMS3_SOC_POINT:60;BAMS4_SOC_POINT:70;BAMS5_SOC_POINT:80;BAMS6_SOC_POINT:70;BAMS7_SOC_POINT:70;BAMS8_SOC_POINT:70";
let total_power_str4 = "GEN_TOTAL_P_POINT:-4000";
let dstr4 = bms_status_str1.to_string() + ";" + agc_mode1;
let astr4 = soc_str4.to_string()
+ ";"
+ mileage_str1
+ ";"
+ rated_mileage_str1
+ ";"
+ bms_capacity_str1
+ ";"
+ max_charging_power_str1
+ ";"
+ max_discharging_power_str1
+ ";"
+ total_power_str4
+ ";"
+ bms_p1;
// Cross-sectional data set 5 (RESULT: Discharge optimal strategy)
let soc_str5 = "BAMS1_SOC_POINT:60;BAMS2_SOC_POINT:70;BAMS3_SOC_POINT:40;BAMS4_SOC_POINT:40;BAMS5_SOC_POINT:30;BAMS6_SOC_POINT:30;BAMS7_SOC_POINT:30;BAMS8_SOC_POINT:30";
let total_power_str5 = "GEN_TOTAL_P_POINT:3500";
let dstr5 = bms_status_str1.to_string() + ";" + agc_mode1;
let astr5 = soc_str5.to_string()
+ ";"
+ mileage_str1
+ ";"
+ rated_mileage_str1
+ ";"
+ bms_capacity_str1
+ ";"
+ max_charging_power_str1
+ ";"
+ max_discharging_power_str1
+ ";"
+ total_power_str5
+ ";"
+ bms_p1;
// Cross-sectional data set 6 (RESULT: Charge optimal strategy)
let soc_str6 = "BAMS1_SOC_POINT:30;BAMS2_SOC_POINT:40;BAMS3_SOC_POINT:60;BAMS4_SOC_POINT:60;BAMS5_SOC_POINT:70;BAMS6_SOC_POINT:60;BAMS7_SOC_POINT:60;BAMS8_SOC_POINT:60";
let total_power_str6 = "GEN_TOTAL_P_POINT:-3500";
let dstr6 = bms_status_str1.to_string() + ";" + agc_mode1;
let astr6 = soc_str6.to_string()
+ ";"
+ mileage_str1
+ ";"
+ rated_mileage_str1
+ ";"
+ bms_capacity_str1
+ ";"
+ max_charging_power_str1
+ ";"
+ max_discharging_power_str1
+ ";"
+ total_power_str6
+ ";"
+ bms_p1;
// Cross-sectional data set 7 (RESULT: Discharge strategy 2)
let soc_str7 = "BAMS1_SOC_POINT:80;BAMS2_SOC_POINT:70;BAMS3_SOC_POINT:50;BAMS4_SOC_POINT:20;BAMS5_SOC_POINT:20;BAMS6_SOC_POINT:20;BAMS7_SOC_POINT:50;BAMS8_SOC_POINT:20";
let total_power_str7 = "GEN_TOTAL_P_POINT:8500";
let dstr7 = bms_status_str1.to_string() + ";" + agc_mode1;
let astr7 = soc_str7.to_string()
+ ";"
+ mileage_str1
+ ";"
+ rated_mileage_str1
+ ";"
+ bms_capacity_str1
+ ";"
+ max_charging_power_str1
+ ";"
+ max_discharging_power_str1
+ ";"
+ total_power_str7
+ ";"
+ bms_p1;
let r = from_file2("tests/test_zq_dispatch/aoe-zq-power-dispatch.csv", false);
if let Err(rc) = r {
println!("parse aoe failed: {:?}", rc);
}
assert!(r.is_ok());
let (points, _) = from_csv2("tests/test_zq_dispatch/points-zq.csv", false).unwrap();
let mut alias: HashMap<String, u64> = HashMap::with_capacity(points.len());
// 先形成别名的map
for m in points.values() {
if !m.alias_id.is_empty() {
let key = m.alias_id.clone();
alias.insert(key, m.point_id);
}
}
let mut aoes = r.unwrap();
let set_measure_tx = aoes[0].measure_sender();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let cloned_set_measure_tx = set_measure_tx.clone();
let cloned_alias = alias.clone();
let job = tokio::spawn(async move {
let mut count = 0;
loop {
match rx.recv().await {
Ok(r) => {
debug!("aoe finish: {}", r.aoe_id);
if r.aoe_id == 30 {
for (from, to, r) in &r.action_result {
debug!("{}->{}", from, to);
debug!("{:?}", r.num_result);
}
}
count += 1;
match count {
// Case1 RESULT: Discharge strategy 1
1 => {
debug!("###### CASE2:Charge strategy 1 ######"); // RESULT: Charge strategy 1
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx,
)
.await;
}
2 => {
debug!("###### CASE3:Discharge strategy 2 ######"); // RESULT: Discharge strategy 2
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx,
)
.await;
}
3 => {
debug!("###### CASE4:Charge strategy 2 ######"); // RESULT: Charge strategy 2
set_points(
dstr4.as_str(),
astr4.as_str(),
&cloned_alias,
&cloned_set_measure_tx,
)
.await;
}
4 => {
debug!("###### CASE5:Discharge optimal strategy ######"); // RESULT: Discharge optimal strategy
set_points(
dstr5.as_str(),
astr5.as_str(),
&cloned_alias,
&cloned_set_measure_tx,
)
.await;
}
5 => {
debug!("###### CASE6:Charge optimal strategy ######"); // RESULT: Discharge optimal strategy
set_points(
dstr6.as_str(),
astr6.as_str(),
&cloned_alias,
&cloned_set_measure_tx,
)
.await;
}
6 => {
debug!("###### CASE7:Discharge strategy 2 ######"); // RESULT: Discharge optimal strategy
set_points(
dstr7.as_str(),
astr7.as_str(),
&cloned_alias,
&cloned_set_measure_tx,
)
.await;
}
_ => {
break;
}
}
}
Err(_) => {
break;
}
}
if count == 7 {
break;
}
}
});
dispatcher.schedule(aoes);
// 设置初始值
debug!("###### CASE1:Discharge strategy 1 ######"); // RESULT: Discharge strategy 1
set_points(dstr1.as_str(), astr1.as_str(), &alias, &set_measure_tx).await;
job.await.unwrap();
dispatcher.shutdown().await;
}
#[tokio::test]
async fn test_aoe_file3() {
use log::debug;
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
// Cross-sectional data set 1 (RESULT: Discharge strategy 1)
let black_start_str1 = "START_TEST3:1";
let dstr1 = black_start_str1.to_string();
let astr1 = "".to_string();
let black_start_str2 = "START_TEST3:0;VT_PCS1_START_COMMAND:1;VT_PCS2_START_COMMAND:1";
let dstr2 = black_start_str2.to_string();
let astr2 = "".to_string();
let black_start_str3 =
"START_TEST3:1;XA_PCS1_ED00:2;VT_PCS1_ERROR:0;XA_PCS2_ED00:2;VT_PCS2_ERROR:0";
let dstr3 = black_start_str3.to_string();
let astr3 = "".to_string();
// let black_start_str32 = "XA_PCS1_ED00:2;VT_PCS1_ERROR:0;XA_PCS2_ED00:0;VT_PCS2_ERROR:1";
// let dstr32 = black_start_str32.to_string();
// let astr32 = "".to_string();
let black_start_str4 = "VT_RJ1_START_COMMAND:1";
let dstr4 = black_start_str4.to_string();
// let astr4 = "".to_string();
//
// let black_start_str5 = "VT_RJ_LACK:2;XA_RJ1toEMS_bIfOnline:0;XA_RJ8toEMS_bPermissiRun:0;XA_RJ1toEMS_bPermissiRun:1;XA_RJ5toEMS_bPermissiRun:1;XA_INTERFACE_RJ1Select:1;XA_INTERFACE_RJ5Select:1";
// let dstr5 = black_start_str5.to_string();
// let astr5 = "".to_string();
// let r = from_file2("tests/aoe-zq-power-dispatch.csv");
// assert!(r.is_ok());
// let points = from_csv2("tests/points-zq.csv").unwrap();
let r = from_file2("tests/test_xa/aoe-xa-EMS20200711.csv", false);
assert!(r.is_ok());
let r2 = from_csv2("tests/test_xa/points-xa20210723.csv", false);
if let Err(rc) = r2 {
println!("Error: {:?}", rc);
}
assert!(r2.is_ok());
let (points, _) = r2.unwrap();
let mut alias: HashMap<String, u64> = HashMap::with_capacity(points.len());
// 先形成别名的map
for m in points.values() {
if !m.alias_id.is_empty() {
let key = m.alias_id.clone();
alias.insert(key, m.point_id);
}
}
let mut aoes = r.unwrap();
let set_measure_tx0 = aoes[0].measure_sender();
let set_measure_tx1 = aoes[1].measure_sender();
let set_measure_tx2 = aoes[2].measure_sender();
let set_measure_tx3 = aoes[3].measure_sender();
// let set_measure_tx4 = aoes[4].measure_sender();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let cloned_set_measure_tx0 = set_measure_tx0.clone();
let cloned_set_measure_tx1 = set_measure_tx1.clone();
let cloned_set_measure_tx2 = set_measure_tx2.clone();
let cloned_set_measure_tx3 = set_measure_tx3.clone();
// let cloned_set_measure_tx4 = set_measure_tx4.clone();
let cloned_alias = alias.clone();
let job = tokio::spawn(async move {
let mut count = 0;
loop {
match rx.recv().await {
Ok(r) => {
debug!("aoe finish: {}", r.aoe_id);
// if r.aoe_id == 1 {
// for (from, to, r) in &r.action_result {
// debug!("{}->{}", from, to);
// debug!("{:?}", r.num_result);
// }
// }
count += 1;
match count {
// Case1 RESULT: Discharge strategy 1
1 => {
debug!("###### CASE2:BLACKSTART strategy 2 ######"); // RESULT: BLACKSTART strategy 2
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx1,
)
.await;
// set_points(dstr2.as_str(), astr2.as_str(), &cloned_alias, &cloned_set_measure_tx2).await;
// set_points(dstr2.as_str(), astr2.as_str(), &cloned_alias, &cloned_set_measure_tx3).await;
// set_points(dstr2.as_str(), astr2.as_str(), &cloned_alias, &cloned_set_measure_tx4).await;
}
2 => {
debug!("###### CASE3:BLACKSTART strategy 31 ######"); // RESULT: BLACKSTART strategy 3
// set_points(dstr3.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx0).await;
// set_points(dstr3.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx1).await;
// set_points(dstr3.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx2).await;
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx3,
)
.await;
// set_points(dstr3.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx4).await;
}
3 => {
debug!("###### CASE4:BLACKSTART strategy 4 ######"); // RESULT: BLACKSTART strategy 4
// set_points(dstr4.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx0).await;
// set_points(dstr4.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx1).await;
set_points(
dstr4.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx2,
)
.await;
// set_points(dstr4.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx3).await;
// set_points(dstr4.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx4).await;
}
// 4 => {
// debug!("###### CASE5:BLACKSTART strategy 5 ######"); // RESULT: Charge strategy 5
// // set_points(dstr5.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx0).await;
// // set_points(dstr5.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx1).await;
// // set_points(dstr5.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx2).await;
// // set_points(dstr5.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx3).await;
// set_points(dstr5.as_str(), astr3.as_str(), &cloned_alias, &cloned_set_measure_tx4).await;
// }
_ => {
break;
}
}
}
Err(_) => {
break;
}
}
if count == 4 {
break;
}
}
});
dispatcher.schedule(aoes);
// 设置初始值
debug!("###### CASE1:BLACKSTART strategy 1 ######"); // RESULT: Discharge strategy 1
set_points(dstr1.as_str(), astr1.as_str(), &alias, &set_measure_tx3).await;
// debug!("###### CASE5:BLACKSTART strategy 1 ######"); // RESULT: Discharge strategy 1
// set_points(dstr5.as_str(), astr1.as_str(), &alias, &set_measure_tx4).await;
// 该策略不会被触发，因为计算点变量未被传送至AOE
job.await.unwrap();
dispatcher.shutdown().await;
}
#[tokio::test]
async fn test_aoe_file4() {
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
let xm1 = "P_xiafa:70;P_zhiling:70;SOC:50;";
let dstr1 = xm1.to_string();
let astr1 = "".to_string();
let xm2 = "ifxiafa:1";
let dstr2 = xm2.to_string();
let astr2 = "".to_string();
let xm3 = "P_xiafa:50;P_zhiling:70;SOC:50;";
let dstr3 = xm3.to_string();
let astr3 = "".to_string();
let r = from_file2("tests/test_xm/aoe-xm-EMS20220215.csv", false);
// let r = from_file2("tests/test_xm2/aoe-xm-EMS20220225.csv");
println!("Aoe parse result : {:?}", r);
assert!(r.is_ok());
let (points, _) = from_csv2("tests/test_xm/points-20220214.csv", false).unwrap();
// let points = from_csv2("tests/test_xm2/points-20220225.csv").unwrap();
let mut alias: HashMap<String, u64> = HashMap::with_capacity(points.len());
// 先形成别名的map
for m in points.values() {
if !m.alias_id.is_empty() {
let key = m.alias_id.clone();
alias.insert(key, m.point_id);
}
}
let cloned_alias = alias.clone();
println!("{:?}", cloned_alias);
let mut aoes = r.unwrap();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let set_measure_tx0 = aoes[0].measure_sender();
let cloned_set_measure_tx0 = set_measure_tx0.clone();
set_points(
dstr1.as_str(),
astr1.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
let job = tokio::spawn(async move {
let mut count = 0;
loop {
match rx.recv().await {
Ok(_) => {
count += 1;
match count {
// Case1 RESULT: Discharge strategy 1
1 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
2 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
3 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
4 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
5 => {
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
_ => {
break;
}
}
}
Err(_) => {
break;
}
}
if count == 5 {
break;
}
}
});
dispatcher.schedule(aoes);
job.await.unwrap();
dispatcher.shutdown().await;
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
}
#[tokio::test]
async fn test_aoe_file5() {
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
let xm1 = "SOC:100;";
let xm11 = "P_xiafa:-150;";
let dstr1 = xm1.to_string();
let astr1 = xm11.to_string();
let xm2 = "ifxiafa:1";
let dstr2 = xm2.to_string();
let astr2 = "".to_string();
let xm3 = "SOC:100;";
let xm33 = "P_xiafa:-150;";
let dstr3 = xm3.to_string();
let astr3 = xm33.to_string();
// let r = from_file2("tests/test_xm/aoe-xm-EMS20220215.csv");
let r = from_file2("tests/test_xm2/aoe-xm-EMS20220225.csv", false);
println!("Aoe parse result : {:?}", r);
assert!(r.is_ok());
// let points = from_csv2("tests/test_xm/points-20220214.csv").unwrap();
let (points, _) = from_csv2("tests/test_xm2/points-20220225.csv", false).unwrap();
let mut alias: HashMap<String, u64> = HashMap::with_capacity(points.len());
// 先形成别名的map
for m in points.values() {
if !m.alias_id.is_empty() {
let key = m.alias_id.clone();
alias.insert(key, m.point_id);
}
}
let cloned_alias = alias.clone();
println!("{:?}", cloned_alias);
let mut aoes = r.unwrap();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let set_measure_tx0 = aoes[0].measure_sender();
let cloned_set_measure_tx0 = set_measure_tx0.clone();
set_points(
dstr1.as_str(),
astr1.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
let job = tokio::spawn(async move {
let mut count = 0;
loop {
match rx.recv().await {
Ok(_) => {
count += 1;
match count {
// Case1 RESULT: Discharge strategy 1
1 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
2 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
3 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
4 => {
set_points(
dstr3.as_str(),
astr3.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
5 => {
set_points(
dstr2.as_str(),
astr2.as_str(),
&cloned_alias,
&cloned_set_measure_tx0,
)
.await;
}
6 => {
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
let discretes = dstr3.as_str();
let analogs = astr3.as_str();
set_points(discretes, analogs, &cloned_alias, &cloned_set_measure_tx0, ).await;
set_points(dstr2.as_str(), astr2.as_str(), &cloned_alias, &cloned_set_measure_tx0).await;
}
_ => {
break;
}
}
}
Err(_) => {
break;
}
}
if count == 6 {
break;
}
}
});
dispatcher.schedule(aoes);
job.await.unwrap();
dispatcher.shutdown().await;
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
}
async fn set_points(
discretes: &str,
analogs: &str,
alias: &HashMap<String, u64>,
tx: &Sender<VarOrMeasures>,
) {
let v: Vec<&str> = discretes.split(';').collect();
let mut result = HashMap::new();
for s in v {
if s.is_empty() {
continue;
}
let bias_to_v: Vec<&str> = s.split(':').collect();
let point_id = alias.get(bias_to_v[0]).unwrap();
result.insert(*point_id, MeasureValue {
point_id: *point_id,
is_discrete: true,
timestamp: get_timestamp(),
analog_value: 0.0,
discrete_value: bias_to_v[1].parse().unwrap(),
is_transformed: false,
transformed_analog: 0.0,
transformed_discrete: 0,
});
}
let v: Vec<&str> = analogs.split(';').collect();
for s in v {
if s.is_empty() {
continue;
}
let bias_to_v: Vec<&str> = s.split(':').collect();
let point_id = alias.get(bias_to_v[0]).unwrap();
result.insert(*point_id, MeasureValue {
point_id: *point_id,
is_discrete: false,
timestamp: get_timestamp(),
analog_value: bias_to_v[1].parse().unwrap(),
discrete_value: 0,
is_transformed: false,
transformed_analog: 0.0,
transformed_discrete: 0,
});
}
let buf = MeasureBuf::new(result, HashMap::with_capacity(0));
tx.send(VarOrMeasures::Measures(buf)).await.unwrap();
}
fn start_measure_loop(
rx: Receiver<(Vec<SetIntValue>, Vec<SetFloatValue>)>,
tx: Sender<VarOrMeasures>,
) {
let (meas_sender, meas_receiver) = bounded(100);
tokio::spawn(async move {
loop {
match meas_receiver.recv().await {
Ok(measures) => {
let msg = VarOrMeasures::Measures(measures);
if let Err(e) = tx.send(msg).await {
log::warn!("!!Failed to send measures to aoe, {:?}", e);
break;
}
}
Err(e) => {
log::warn!("!!Failed to receive measures, {:?}", e);
break;
}
}
}
});
tokio::spawn(async move {
while let Ok((d, a)) = rx.recv().await {
let mut result = HashMap::new();
for v in d {
result.insert(v.point_id, MeasureValue {
point_id: v.point_id,
is_discrete: true,
timestamp: get_timestamp(),
analog_value: 0.0,
discrete_value: v.yk_command,
is_transformed: false,
transformed_analog: 0.0,
transformed_discrete: 0,
});
}
for v in a {
result.insert(v.point_id, MeasureValue {
point_id: v.point_id,
is_discrete: false,
timestamp: get_timestamp(),
analog_value: v.yt_command,
discrete_value: 0,
is_transformed: false,
transformed_analog: 0.0,
transformed_discrete: 0,
});
}
let buf =MeasureBuf::new(result, HashMap::new());
meas_sender.send(buf).await.unwrap();
}
});
}
#[tokio::test]
async fn test_set_points_check() {
// let log_env = env_logger::Env::default().default_filter_or("trace");
// env_logger::Builder::from_env(log_env).init();
let r = from_file2("tests/other/aoe-set-points-with-check.csv", false);
assert!(r.is_ok());
let (points, _) = from_csv2("tests/other/points-set-points-with-check.csv", false).unwrap();
let mut aoes = r.unwrap();
for aoe in &mut aoes {
let r = initial_aoe_points(aoe, &points);
assert_eq!(None, r);
assert_eq!(aoe.context.len(), 3);
// 监听AOE发出来的命令
start_measure_loop(aoe.control_receiver(), aoe.measure_sender());
}
let mut dispatcher = Dispatcher::new();
let rx = dispatcher.result_receiver();
let job = tokio::spawn(async move {
if let Ok(r) = rx.recv().await {
println!("aoe finish: {:?}", r);
assert_eq!(3, r.event_result.len());
assert_eq!(2, r.action_result.len());
}
});
dispatcher.schedule(aoes);
job.await.unwrap();
dispatcher.shutdown().await;
}
}
eig-aoe/src/lib.rs
......@@ -355,308 +355,3 @@ impl MeasureBuf {
status.is_some() && status.unwrap().discrete_value > 0
}
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use ndarray::array;
use num_complex::Complex64;
use eig_expr::{MyCx, MyF};
use crate::exprgraph::{cal_exprs, cal_exprs_cx};
#[test]
fn it_works() {
let s = "a=1+2;a+2;";
let r = cal_exprs(s);
assert_eq!(
r,
Ok((vec![("a".to_string(), MyF::F64(3.))], vec![MyF::F64(5.)]))
);
let s = "a=c(1,1);a+2;";
let r = cal_exprs_cx(s);
assert_eq!(
r,
Ok((
vec![("a".to_string(), MyCx::F64(Complex64::new(1., 1.)))],
vec![MyCx::F64(Complex64::new(3., 1.))]
))
);
let s = "a=[1,2,3];a+2;";
let r = cal_exprs(s);
assert_eq!(
r,
Ok((
vec![("a".to_string(), MyF::Tensor(array![1., 2., 3.].into_dyn()))],
vec![MyF::Tensor(array![3., 4., 5.].into_dyn())]
))
);
let s = "a=[1,2,c(1,2)];a+2;";
let r = cal_exprs_cx(s);
assert_eq!(
r,
Ok((
vec![(
"a".to_string(),
MyCx::Tensor(
array![
Complex64::new(1., 0.),
Complex64::new(2., 0.),
Complex64::new(1., 2.)
]
.into_dyn()
)
)],
vec![MyCx::Tensor(
array![
Complex64::new(3., 0.),
Complex64::new(4., 0.),
Complex64::new(3., 2.)
]
.into_dyn()
)]
))
);
}
#[cfg(feature = "solvers")]
#[test]
fn test_inv() {
use eig_expr::{CtxProvider, ContextProvider};
let ctx = CtxProvider::new();
let ctx2: HashMap<String, MyCx> = HashMap::new();
let r = ctx.matrix_inv_cx(&array![[Complex64::new(1.0, 0.)]]);
assert_eq!(r, Ok(array![[Complex64::new(1.0, 0.)]]));
let r = (&ctx, &ctx2).matrix_inv_cx(&array![[Complex64::new(1.0, 0.)]]);
assert_eq!(r, Ok(array![[Complex64::new(1.0, 0.)]]));
}
#[test]
fn test_2_1() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case2_1.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
}
#[test]
fn test_3_8() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case3_8.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, expr_result) = r.unwrap();
assert_eq!(27, var_result.len());
assert_eq!(1, expr_result.len());
let mut map = HashMap::with_capacity(var_result.len());
for (name, v) in var_result {
map.insert(name, v);
}
assert_eq!(
map.get("TAPab").cloned(),
Some(MyCx::F64(Complex64::new(6., 0.)))
);
assert_eq!(
map.get("TAPcb").cloned(),
Some(MyCx::F64(Complex64::new(4., 0.)))
);
println!("{:?}", expr_result[0]);
}
#[cfg(feature = "solvers")]
#[test]
fn test_4_1() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case4_1.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, expr_result) = r.unwrap();
assert_eq!(1, expr_result.len());
let mut map = HashMap::with_capacity(var_result.len());
for (name, v) in var_result {
map.insert(name, v);
}
assert_eq!(22, map.len());
println!("{:?}", map.get("Iabc"));
println!("{:?}", map.get("Iabc_ref"));
println!("{:?}", map.get("VLGabc"));
println!("{:?}", map.get("VLGabc_ref"));
println!("{:?}", expr_result[0]);
}
#[test]
fn test_4_2() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case4_2.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _expr_result) = r.unwrap();
let mut map = HashMap::with_capacity(var_result.len());
for (name, v) in var_result {
map.insert(name, v);
}
assert_eq!(29, map.len());
println!("=================== Ztab ==========");
println!("{:?}", map.get("Ztab"));
println!("=================== Ztbc ==========");
println!("{:?}", map.get("Ztbc"));
println!("=================== Ztca ==========");
println!("{:?}", map.get("Ztca"));
println!("=================== at ==========");
println!("{:?}", map.get("at"));
println!("=================== bt ==========");
println!("{:?}", map.get("bt"));
println!("=================== dt ==========");
println!("{:?}", map.get("dt"));
println!("=================== At ==========");
println!("{:?}", map.get("At"));
println!("=================== Bt ==========");
println!("{:?}", map.get("Bt"));
println!("=================== IDabc ==========");
println!("{:?}", map.get("IDabc"));
println!("=================== IDabc_ref ==========");
println!("{:?}", map.get("IDabc_ref"));
println!("=================== Iabc ==========");
println!("{:?}", map.get("Iabc"));
println!("=================== Iabc_ref ==========");
println!("{:?}", map.get("Iabc_ref"));
println!("=================== VLNabc ==========");
println!("{:?}", map.get("VLNabc"));
println!("=================== VLNabc_ref ==========");
println!("{:?}", map.get("VLNabc_ref"));
println!("=================== VLNABC ==========");
println!("{:?}", map.get("VLNABC"));
println!("=================== VLNABC_ref ==========");
println!("{:?}", map.get("VLNABC_ref"));
println!("=================== ST ==========");
println!("{:?}", map.get("ST"));
println!("=================== ST_ref ==========");
println!("{:?}", map.get("ST_ref"));
}
#[test]
fn test_4_3() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case4_3.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _) = r.unwrap();
let mut map = HashMap::with_capacity(var_result.len());
for (name, v) in var_result {
map.insert(name, v);
}
assert_eq!(31, map.len());
println!("=================== VLNabc ==========");
println!("{:?}", map.get("VLNabc"));
println!("=================== VLNabc_ref ==========");
println!("{:?}", map.get("VLNabc_ref"));
println!("=================== VLNabc_known ==========");
println!("{:?}", map.get("VLNabc_known"));
}
#[test]
fn test_4_4() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case4_4.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _expr_result) = r.unwrap();
let mut map = HashMap::with_capacity(var_result.len());
for (name, v) in var_result {
map.insert(name, v);
}
assert_eq!(21, map.len());
println!("=================== VLGABC ==========");
println!("{:?}", map.get("VLGABC"));
println!("=================== VLGABC_ref ==========");
println!("{:?}", map.get("VLGABC_ref"));
println!("=================== IABC ==========");
println!("{:?}", map.get("IABC"));
println!("=================== IABC_ref ==========");
println!("{:?}", map.get("IABC_ref"));
}
#[test]
fn test_4_5() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case4_5.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _) = r.unwrap();
let mut map = HashMap::with_capacity(var_result.len());
for (name, v) in var_result {
map.insert(name, v);
}
assert_eq!(35, map.len());
println!("=================== Zthabc ==========");
println!("{:?}", map.get("Zthabc"));
println!("=================== Zthabc_ref ==========");
println!("{:?}", map.get("Zthabc_ref"));
println!("=================== Ethabc ==========");
println!("{:?}", map.get("Ethabc"));
println!("=================== Ethabc_ref ==========");
println!("{:?}", map.get("Ethabc_ref"));
}
#[test]
fn test_5_3() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case5_3.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _) = r.unwrap();
assert_eq!(31, var_result.len());
}
#[test]
fn test_5_5() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case5_5.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _) = r.unwrap();
assert_eq!(13, var_result.len());
}
#[cfg(feature = "solvers")]
#[test]
fn test_5_6() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case5_6.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _) = r.unwrap();
assert_eq!(18, var_result.len());
}
#[test]
fn test_6_1() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case6_1.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
let (var_result, _) = r.unwrap();
assert_eq!(16, var_result.len());
}
#[test]
fn test_6_2() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/case6_2.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
}
#[test]
fn test_exer3_5() {
let content =
String::from_utf8(std::fs::read("tests/test_calculator/exer3_5.txt").unwrap()).unwrap();
let r = cal_exprs_cx(&content);
assert!(r.is_ok());
}
}
eig-aoe/src/solvers/mod.rs
......@@ -9,135 +9,3 @@ pub use utils::*;
pub mod model;
pub mod utils;
\ No newline at end of file
#[allow(non_snake_case)]
#[cfg(test)]
mod tests {
use std::f64::consts::PI;
use std::ops::Mul;
use approx::assert_relative_eq;
use ndarray::array;
use num::pow::Pow;
use num_complex::{Complex64, ComplexFloat};
//noinspection ALL
#[test]
fn test_2_1() {
let GMRabc = 0.00744;
let _GMRn = 0.00248;
let rabc = 0.190;
let _rn = 0.368;
let Dab = 0.7622;
let _Dbc = 1.3720;
let _Dca = 2.1342;
let _Dan = 1.7247;
let _Dbn = 1.3025;
let _Dcn = 1.5244;
let zaa = Complex64::new(rabc + 0.0493, 0.0628 * ((1.0 / GMRabc).ln() + 8.02517));
assert_relative_eq!(zaa.re, 0.2393, max_relative = 1e-4);
assert_relative_eq!(zaa.im, 0.8118, max_relative = 1e-4);
// let zaa = Complex64::new(0.2393, 0.8118);
let zab = Complex64::new(0.0493, 0.0628 * ((1.0 / Dab).ln() + 8.02517));
assert_relative_eq!(zab.im, 0.5210, max_relative = 1e-4);
// let zab = Complex64::new(0.0493, 0.5210);
let zac = Complex64::new(0.0493, 0.4564);
let zan = Complex64::new(0.0493, 0.4698);
let zbc = Complex64::new(0.0493, 0.4841);
let zbn = Complex64::new(0.0493, 0.4874);
let zcn = Complex64::new(0.0493, 0.4775);
let znn = array![Complex64::new(0.4173, 0.8807)];
let zij = array![[zaa, zab, zac], [zab, zaa, zbc], [zac, zbc, zaa]];
let zin = array![[zan], [zbn], [zcn]];
let znj = array![zan, zbn, zcn];
let zabc = zij - zin.mul(array![Complex64::new(1.0, 0.0)] / znn).mul(znj);
println!("{:?}", zabc);
let a = Complex64::new(f64::cos(2.0 * PI / 3.0), f64::sin(2.0 * PI / 3.0));
println!("as: {:?}", a);
let matrix_as = array![
[
Complex64::new(1.0, 0.0),
Complex64::new(1.0, 0.0),
Complex64::new(1.0, 0.0)
],
[Complex64::new(1.0, 0.0), a * a, a],
[Complex64::new(1.0, 0.0), a, a * a]
];
println!("As: {:?}", matrix_as);
let matrix_as_inv = array![
[
Complex64::new(1.0 / 3.0, 0.0),
Complex64::new(1.0 / 3.0, 0.0),
Complex64::new(1.0 / 3.0, 0.0)
],
[
Complex64::new(1.0 / 3.0, 0.0),
a * Complex64::new(1.0 / 3.0, 0.0),
a * a * Complex64::new(1.0 / 3.0, 0.0)
],
[
Complex64::new(1.0 / 3.0, 0.0),
a * a * Complex64::new(1.0 / 3.0, 0.0),
a * Complex64::new(1.0 / 3.0, 0.0)
]
];
println!("As_inv {:?}", matrix_as_inv);
println!("As_inv * As: {:?}", matrix_as_inv.dot(&matrix_as));
let temp = matrix_as_inv.dot(&zabc);
let z012 = temp.dot(&matrix_as);
// let z012 = As_inv * zabc * As;
assert_relative_eq!(z012.get([0, 0]).unwrap().re(), 0.5050, max_relative = 1e-4);
}
//noinspection ALL
#[test]
#[allow(non_snake_case)]
fn test_2_2() {
let GMRc = 0.005212;
let GMRs = 0.000634;
let dod = 3.2766;
let _dc = 1.4402;
let rc = 0.2548;
let ds = 0.162814;
let rs = 9.2411;
let k = 13.0;
let R = (dod - ds) / 200.;
assert_relative_eq!(R, 0.01557, max_relative = 1e-4);
let tmp: f64 = GMRs * k * R.pow(k - 1.0);
let GMRcn = tmp.pow(1.0 / k);
assert_relative_eq!(GMRcn, 0.01483, max_relative = 1e-3);
let rcn = rs / k;
let D12 = 0.1524;
let D45 = 0.1524;
let _D23 = 0.1524;
let _D56 = 0.1524;
let D13 = 0.3048;
let D46 = 0.3048;
let D14 = 0.01557;
let _D25 = 0.01557;
let _D36 = 0.01557;
let D15 = 0.1524;
let _D26 = 0.1524;
let D16 = 0.3048;
let z11 = Complex64::new(rc + 0.0493, 0.0628 * ((1.0 / GMRc).ln() + 8.02517));
assert_relative_eq!(z11.re, 0.3041, max_relative = 1e-4);
assert_relative_eq!(z11.im, 0.8341, max_relative = 1e-4);
let z12 = Complex64::new(0.0493, 0.0628 * ((1.0 / D12).ln() + 8.02517));
assert_relative_eq!(z12.im, 0.6221, max_relative = 1e-4);
let z13 = Complex64::new(0.0493, 0.0628 * ((1.0 / D13).ln() + 8.02517));
assert_relative_eq!(z13.im, 0.5786, max_relative = 1e-4);
let z14 = Complex64::new(0.0493, 0.0628 * ((1.0 / D14).ln() + 8.02517));
assert_relative_eq!(z14.im, 0.7654, max_relative = 1e-4);
let z15 = Complex64::new(0.0493, 0.0628 * ((1.0 / D15).ln() + 8.02517));
assert_relative_eq!(z15.im, 0.6221, max_relative = 1e-4);
let z16 = Complex64::new(0.0493, 0.0628 * ((1.0 / D16).ln() + 8.02517));
assert_relative_eq!(z16.im, 0.5786, max_relative = 1e-4);
let z44 = Complex64::new(rcn + 0.0493, 0.0628 * ((1.0 / GMRcn).ln() + 8.02517));
assert_relative_eq!(z44.re, 0.7602, max_relative = 1e-4);
assert_relative_eq!(z44.im, 0.7684, max_relative = 1e-4);
let z45 = Complex64::new(0.0493, 0.0628 * ((1.0 / D45).ln() + 8.02517));
assert_relative_eq!(z45.im, 0.6221, max_relative = 1e-4);
let z46 = Complex64::new(0.0493, 0.0628 * ((1.0 / D46).ln() + 8.02517));
assert_relative_eq!(z46.im, 0.5786, max_relative = 1e-4);
}
}
eig-aoe/src/solvers/utils.rs
......@@ -961,7 +961,7 @@ mod tests {
r.unwrap()
);
let expr: Expr = "6-x1+ x2/2!".parse().unwrap();
let expr: Expr = "6-x1+ x2/!2".parse().unwrap();
let r = split_linear_expr(expr.rpn, &x_pos);
assert_eq!(
vec![
......@@ -972,7 +972,7 @@ mod tests {
r.unwrap()
);
let expr: Expr = "6-x1+ x2/var1!".parse().unwrap();
let expr: Expr = "6-x1+ x2/!var1".parse().unwrap();
let r = split_linear_expr(expr.rpn, &x_pos);
assert_eq!(
vec![
......@@ -991,7 +991,7 @@ mod tests {
r.unwrap()
);
let expr: Expr = "-6-x1-(5>=4)*3*x2/var1!".parse().unwrap();
let expr: Expr = "-6-x1-(5>=4)*3*x2/!var1".parse().unwrap();
let r = split_linear_expr(expr.rpn, &x_pos);
assert_eq!(
vec![
......@@ -1012,7 +1012,7 @@ mod tests {
r.unwrap()
);
let expr: Expr = "-6-x1-((5>=4)*3*x2/2! + (4<=1))*4".parse().unwrap();
let expr: Expr = "-6-x1-((5>=4)*3*x2/!2 + (4<=1))*4".parse().unwrap();
let r = split_linear_expr(expr.rpn, &x_pos);
assert_eq!(
vec![
......
eig-domain/src/dlt645.rs
......@@ -592,187 +592,3 @@ impl RegisterData {
})
}
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use crate::dlt645::{Dlt645ClientTp, Dlt645Para};
use crate::{SerialPara, SerialParity};
use crate::env::Env;
#[test]
fn test_parse_dlt_csv() {
Env::init("");
Env::set_vitrual_env();
let tp = Dlt645ClientTp::from_csv("tests/dlt645-test1.csv").unwrap();
assert_eq!(tp.name, "DLT测试通道");
assert_eq!(tp.connections.len(), 2);
assert_eq!(
tp.para,
Dlt645Para::Serial(SerialPara {
file_path: "/dev/ttyUSB0".to_string(),
baud_rate: 19200,
data_bits: 10,
stop_bits: 2,
parity: SerialParity::Odd,
delay_between_requests: 20,
})
);
let connection = tp.connections.first().unwrap();
assert_eq!(connection.name, "测试通道1");
assert_eq!(connection.slave_id, 0x00_00_00_34_03_10_98_67);
assert_eq!(connection.default_polling_period_in_milli, 5000);
assert_eq!(connection.timeout_in_milli, 1000);
assert_eq!(connection.polling_period_to_data.len(), 1);
assert_eq!(
connection
.polling_period_to_data
.get(&5000u64)
.unwrap()
.len(),
10
);
assert_eq!(connection.data_configure.len(), 10);
assert_eq!(
connection.data_configure.first().unwrap().data_id,
0x00_00_00_00
);
assert_eq!(connection.data_configure.first().unwrap().point_ids.len(), 1);
assert_eq!(connection.data_configure.first().unwrap().point_ids[0], 4001);
assert_eq!(
connection
.data_configure.first()
.unwrap()
.polling_period_in_milli,
5000
);
assert_eq!(
connection.data_configure.get(6).unwrap().data_id,
0x01_01_00_00
);
assert_eq!(connection.data_configure.get(6).unwrap().point_ids.len(), 2);
assert_eq!(connection.data_configure.get(6).unwrap().point_ids[0], 4007);
assert_eq!(connection.data_configure.get(6).unwrap().point_ids[1], 4011);
assert_eq!(
connection
.data_configure
.get(6)
.unwrap()
.polling_period_in_milli,
5000
);
assert_eq!(connection.data_configure.get(9).unwrap().point_ids[0], 4010);
assert_eq!(
connection.data_configure.get(9).unwrap().data_id,
0x02_80_00_0A
);
assert_eq!(
connection
.data_configure
.get(9)
.unwrap()
.polling_period_in_milli,
5000
);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.data_configure.len(), 20);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = Dlt645ClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_parse_dlt_csv2() {
let tp = Dlt645ClientTp::from_csv("tests/dlt645-test2.csv").unwrap();
assert_eq!(tp.name, "DLT测试通道");
assert_eq!(tp.connections.len(), 2);
assert_eq!(tp.para, Dlt645Para::Socket("127.0.0.1".to_string(), 2300));
let connection = tp.connections.first().unwrap();
assert_eq!(connection.name, "测试通道1");
assert_eq!(connection.slave_id, 0x00_00_00_34_03_10_98_67);
assert_eq!(connection.default_polling_period_in_milli, 5000);
assert_eq!(connection.timeout_in_milli, 1000);
assert_eq!(connection.polling_period_to_data.len(), 1);
assert_eq!(
connection
.polling_period_to_data
.get(&5000u64)
.unwrap()
.len(),
10
);
assert_eq!(connection.data_configure.len(), 10);
assert_eq!(
connection.data_configure.first().unwrap().data_id,
0x00_00_00_00
);
assert_eq!(connection.data_configure.first().unwrap().point_ids.len(), 1);
assert_eq!(connection.data_configure.first().unwrap().point_ids[0], 4001);
assert_eq!(
connection
.data_configure.first()
.unwrap()
.polling_period_in_milli,
5000
);
assert_eq!(
connection.data_configure.get(6).unwrap().data_id,
0x01_01_00_00
);
assert_eq!(connection.data_configure.get(6).unwrap().point_ids.len(), 2);
assert_eq!(connection.data_configure.get(6).unwrap().point_ids[0], 4007);
assert_eq!(connection.data_configure.get(6).unwrap().point_ids[1], 4011);
assert_eq!(
connection
.data_configure
.get(6)
.unwrap()
.polling_period_in_milli,
5000
);
assert_eq!(connection.data_configure.get(9).unwrap().point_ids[0], 4010);
assert_eq!(
connection.data_configure.get(9).unwrap().data_id,
0x02_80_00_0A
);
assert_eq!(
connection
.data_configure
.get(9)
.unwrap()
.polling_period_in_milli,
5000
);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.data_configure.len(), 20);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = Dlt645ClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
// #[test]
// fn test_export_dlt_model() {
// let tp1 = Dlt645ClientTp::from_csv("tests/dlt645-test1.csv").unwrap();
// let tp1_export = tp1.export_model();
// let tp1_parse_from_export = Dlt645ClientTp::from_csv_bytes(tp1_export.as_bytes());
// assert_eq!(tp1_parse_from_export, Ok(tp1));
// let tp2 = Dlt645ClientTp::from_csv("tests/dlt645-test2.csv").unwrap();
// let tp2_export = tp2.export_model();
// let tp2_parse_from_export = Dlt645ClientTp::from_csv_bytes(tp2_export.as_bytes());
// assert_eq!(tp2_parse_from_export, Ok(tp2));
// }
}
eig-domain/src/ethercat.rs
......@@ -502,17 +502,3 @@ impl PdiData {
})
}
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_file() {
let file = "tests/ethercat-transport-test1.csv";
let tp = EcMasterTp::from_file(file);
assert!(tp.is_ok());
let tp = tp.unwrap();
assert_eq!("enp5s0", tp.eth);
}
}
\ No newline at end of file
eig-domain/src/excel.rs
......@@ -205,160 +205,4 @@ fn get_encoding(data: &[u8]) -> FileEncode {
}
}
return FileEncode::UTF8;
}
#[cfg(test)]
mod tests {
use std::io::{Cursor, Read, Write};
use super::*;
#[test]
fn test_parse() {
let bytes = std::fs::read("../eig-domain/tests/points-test1.xlsx").unwrap();
let mut c = Cursor::new(Vec::new());
c.write_all(bytes.as_slice()).unwrap();
let mut xl = open_workbook_auto_from_rs(c).unwrap();
let names = xl.sheet_names().to_owned();
let bytes = sheets_to_csv(&mut xl, names).unwrap()[0].clone();
let mut buf = String::new();
bytes.as_slice().read_to_string(&mut buf).unwrap();
println!("{}", buf);
}
#[test]
fn test_parse_points() {
use crate::{from_csv, from_csv_bytes2};
let path1 = "tests/points-test1.xlsx";
let path2 = "tests/points-test1.csv";
let bytes = excel_to_csv_bytes(path1).unwrap()[0].clone();
let (map1, tags1) = from_csv_bytes2(bytes.as_slice(), true, false).unwrap();
let (map2, tags2) = from_csv(path2).unwrap();
for key in map2.keys() {
assert_eq!(map1.get(key), map2.get(key));
}
assert_eq!(tags1, tags2);
}
#[test]
fn test_parse_points2() {
use crate::{from_csv, from_csv_bytes2};
let path1 = "tests/points-test1.csv";
let path2 = "tests/points-test1.csv";
let bytes = excel_to_csv_bytes(path1).unwrap()[0].clone();
let (map1, tags1) = from_csv_bytes2(bytes.as_slice(), true, false).unwrap();
let (map2, tags2) = from_csv(path2).unwrap();
for key in map2.keys() {
assert_eq!(map1.get(key), map2.get(key));
}
assert_eq!(tags1, tags2);
}
// #[test]
// fn test_parse_aoes() {
// use eig_aoe::aoe::parse::{from_csv_bytes, from_file};
// let path = "../eig-aoe/tests/test_zq/aoe-test1.xlsx";
// let path2 = "../eig-aoe/tests/test_zq/aoe-test1.csv";
// let bytes = excel_to_csv_bytes(path).unwrap()[0].clone();
// let aoes1 = from_csv_bytes(bytes.as_slice()).unwrap();
// let aoes2 = from_file(path2).unwrap();
// assert_eq!(3, aoes2.len());
// for i in 0..aoes2.len() {
// assert_eq!(aoes1[i].model, aoes2[i].model);
// }
// }
#[test]
fn test_parse_mbtcps() {
use crate::modbus::ModbusTcpClientTp;
let path = "tests/tcp-mbc-test1.xlsx";
let path2 = "tests/tcp-mbc-test1.csv";
let bytes = excel_to_csv_bytes(path).unwrap()[0].clone();
let mut buf = String::new();
bytes.as_slice().read_to_string(&mut buf).unwrap();
println!("{}", buf);
let tps1 = ModbusTcpClientTp::from_csv_bytes2(bytes.as_slice()).unwrap();
let tps2 = ModbusTcpClientTp::from_csv2(path2).unwrap();
assert_eq!(tps1, tps2);
}
#[test]
fn test_parse_kanban() {
let xlsx_bytes = std::fs::read("tests/kanban1.xlsx").unwrap();
let (m, n, merged_cells) = get_first_sheet_merged_cells(xlsx_bytes).unwrap();
assert_eq!(m, 6);
assert_eq!(n, 12);
let mut is_dealt = vec![false; (m * n) as usize];
let mut cells = Vec::new();
for i in 0..m {
for j in 0..n {
let index = (i * n + j) as usize;
if is_dealt[index] {
continue;
}
let mut class_str = "cell".to_string();
let coordinate = (i, j);
if let Some((end_row, end_col)) = merged_cells.get(&coordinate) {
let row_span = *end_row - i + 1;
let col_span = *end_col - j + 1;
if row_span > 1 {
class_str.push_str(&format!(" is-row-span-{row_span}"))
}
if col_span > 1 {
class_str.push_str(&format!(" is-col-span-{col_span}"))
}
cells.push(class_str);
for row in i..=*end_row {
for col in j..=*end_col {
let pos = (row * n + col) as usize;
is_dealt[pos] = true;
}
}
} else {
cells.push(class_str);
}
}
}
assert_eq!(23, cells.len());
}
#[test]
fn test_parse_kanban2() {
let xlsx_bytes = std::fs::read("tests/kanban2.xlsx").unwrap();
let (m, n, _) = get_first_sheet_merged_cells(xlsx_bytes).unwrap();
assert_eq!(m, 7);
assert_eq!(n, 12);
let xlsx_bytes = std::fs::read("tests/kanban3.xlsx").unwrap();
let (m, n, _) = get_first_sheet_merged_cells(xlsx_bytes).unwrap();
assert_eq!(m, 7);
assert_eq!(n, 12);
}
#[test]
fn test_parse_file() {
let content = std::fs::read("tests/GBK.txt").unwrap();
let encoding = get_encoding(content.as_slice());
assert_eq!(encoding, FileEncode::GBK);
let gbk = transfer_to_utf8(content).unwrap();
let content = std::fs::read("tests/UTF8.txt").unwrap();
let encoding = get_encoding(content.as_slice());
assert_eq!(encoding, FileEncode::UTF8);
let utf8 = transfer_to_utf8(content).unwrap();
assert_eq!(gbk, utf8);
}
}
\ No newline at end of file
eig-domain/src/hymqtt.rs
......@@ -451,137 +451,3 @@ impl HYMqttTransport {
result
}
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use crate::hymqtt::{HYMqttTransport, HYPoint, HYPointInfo};
use chrono::prelude::*;
use serde_json::json;
#[test]
fn test_parse_hy_mqtt_csv() {
let tp = HYMqttTransport::from_csv("tests/ttu-test.csv").unwrap();
assert_eq!(tp.name, "HYMQTT测试");
assert_eq!(tp.mqtt_broker, ("127.0.0.1".to_string(), 1883u16));
assert_eq!(tp.read_topic, "gwIn/read");
assert_eq!(tp.write_topic, "gwOut/write");
assert_eq!(tp.user_name.unwrap(), "admin");
assert_eq!(tp.user_password.unwrap(), "admin");
assert_eq!(tp.app_name, "plcc");
assert_eq!(tp.poll_time, 1000);
assert!(tp.is_poll);
assert_eq!(tp.point_id, 9001);
assert_eq!(tp.is_new, false);
assert_eq!(tp.point_id_to_pos.len(), 10);
println!("{:?}", tp.point_id_to_pos);
println!("{:?}", tp.data_configure);
println!("{:?}", tp.model_to_pos);
println!("{:?}", tp.device_configure);
}
#[test]
fn test_json() {
let fmt = "%Y-%m-%dT%H:%M:%S%.3f%z";
let now: DateTime<Local> = Local::now();
let dft = now.format(fmt);
let str_date = dft.to_string();
println!("time: {}", str_date);
let name = "macc".to_string();
let tp = HYPoint {
not_realtime: false,
device_id: 0,
point_id: 0,
point_info: HYPointInfo {
name: "MACC".to_string(),
r#type: "float".to_string(),
unit: "".to_string(),
deadzone: "0".to_string(),
ratio: "0".to_string(),
isReport: "0".to_string(),
userdefine: "0".to_string(),
},
};
let tp = vec![tp.point_info.clone(), tp.point_info];
let register = json!({
"token": 123,
"timestamp": name,
"body":tp,
});
let mut bodys = json!([]);
for i in 0..3 {
let body = json!({
"model": i,
"port": i,
});
bodys.as_array_mut().unwrap().push(body);
}
// register.as_object_mut().unwrap().insert("Vec[body]".to_string(), bodys);
let register = json!([register, bodys]);
let v = serde_json::to_string(&register).unwrap();
println!("{}", v);
// {
// "Vec[body]": [
// { "model": 0,
// "port": 0
// },
// { "model": 1,
// "port": 1
// },
// { "model": 2,
// "port": 2
// }
// ],
// "body": [
// { "deadzone": "0", "isReport": "0", "name": "MACC", "ratio": "0",
// "type": "float", "unit": "", "userdefine": "0"
// },
// { "deadzone": "0", "isReport": "0", "name": "MACC", "ratio": "0",
// "type": "float", "unit": "", "userdefine": "0"
// }
// ],
// "timestamp": "2022-12-02T20:39:55.966+0800",
// "token": 123
// }
}
// 测试json用serde_json解析
// 结论：时间好像差不多，但是serde_json解析json的速度还稍微有点慢
#[test]
fn test_serde() {
let tp = HYPoint {
not_realtime: false,
device_id: 0,
point_id: 0,
point_info: HYPointInfo {
name: "MACC".to_string(),
r#type: "float".to_string(),
unit: "".to_string(),
deadzone: "0".to_string(),
ratio: "0".to_string(),
isReport: "0".to_string(),
userdefine: "0".to_string(),
},
};
let mut bodys = json!([]);
for _i in 0..500 {
let body = json!(tp);
bodys.as_array_mut().unwrap().push(body);
}
let v = serde_json::to_string(&bodys).unwrap();
// 解析json，记录时间
let begin = Local::now();
for _ in 0..10 {
let test_json: serde_json::Value = serde_json::from_str(&v).unwrap();
for body in test_json.as_array().unwrap() {
//let name = body["point_info"]["name"].as_str().unwrap();
let point: HYPoint = serde_json::from_value(body.clone()).unwrap();
let _name = &point.point_info.name;
// println!("{:?}", point);
}
}
let end = Local::now();
let duration = end - begin;
println!("duration: {:?}", duration);
}
}
eig-domain/src/iec104.rs
......@@ -1051,90 +1051,3 @@ impl Iec104Point {
})
}
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use crate::iec104::Iec104ClientTp;
use crate::Iec104ServerTp;
#[test]
fn test_iec_client_from_csv() {
let tp = Iec104ClientTp::from_csv("tests/iec104c-test1.csv").unwrap();
assert_eq!(tp.name, "iec104测试通道1");
assert_eq!(tp.tcp_server.0, "127.0.0.1");
assert_eq!(tp.tcp_server.1, 2404);
assert_eq!(tp.yx_data_type, 1);
assert_eq!(tp.yc_data_type, 13);
assert_eq!(tp.connection.originator_address, 0);
assert_eq!(tp.connection.common_address, 1);
assert_eq!(tp.connection.point_id, 109001);
assert_eq!(tp.connection.cot_field_length, 2);
assert_eq!(tp.connection.common_address_field_length, 2);
assert_eq!(tp.connection.max_idle_time, 20000);
assert_eq!(tp.connection.max_time_no_ack_received, 15000);
assert_eq!(tp.connection.max_time_no_ack_sent, 10000);
assert_eq!(tp.connection.data_configure.len(), 10);
assert!(!tp.connection.is_control_with_time);
assert!(!tp.connection.direct_yk);
assert!(!tp.connection.direct_yt);
assert_eq!(tp.connection.data_configure[0].ioa, 1);
assert_eq!(tp.connection.data_configure[0].point_id, 104001);
assert!(!tp.connection.data_configure[0].is_yx);
assert_eq!(tp.connection.data_configure[0].control_ioa, Some(6001));
assert_eq!(tp.connection.call_time, Some(10000));
assert_eq!(tp.connection.call_counter_time, Some(10000));
assert!(tp.connection.is_client);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = Iec104ClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_iec_server_from_csv() {
let tp = Iec104ServerTp::from_csv("tests/iec104d-test1.csv").unwrap();
assert_eq!(tp.name, "iec104服务通道1");
assert_eq!(tp.tcp_server_port, 2404);
assert_eq!(tp.yx_data_type, 1);
assert_eq!(tp.yc_data_type, 13);
assert_eq!(tp.connections.len(), 2);
assert_eq!(tp.connections[0].1.originator_address, 0);
assert_eq!(tp.connections[0].1.common_address, 1);
assert_eq!(tp.connections[0].1.point_id, 102404);
assert_eq!(tp.connections[0].1.cot_field_length, 2);
assert_eq!(tp.connections[0].1.common_address_field_length, 2);
assert_eq!(tp.connections[0].1.max_idle_time, 20000);
assert_eq!(tp.connections[0].1.max_time_no_ack_received, 15000);
assert_eq!(tp.connections[0].1.max_time_no_ack_sent, 10000);
assert_eq!(tp.connections[0].1.data_configure.len(), 10);
assert!(!tp.connections[0].1.is_control_with_time);
assert!(!tp.connections[0].1.direct_yk);
assert!(!tp.connections[0].1.direct_yt);
assert!(!tp.connections[0].1.is_client);
assert!(!tp.connections[0].1.data_configure[0].is_yx);
assert!(tp.connections[0].1.data_configure[0].control_ioa.is_some());
assert_eq!(tp.connections[0].1.call_time, Some(10000));
assert_eq!(tp.connections[0].1.call_counter_time, Some(10000));
assert!(tp.connections[1].1.data_configure[0].control_ioa.is_none());
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = Iec104ServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_export_iec_server_model() {
let tp = Iec104ServerTp::from_file("tests/iec104d-transport-example.xlsx").unwrap();
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = Iec104ServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_export_iec_server_model2() {
let tp = Iec104ServerTp::from_file("tests/iec104d-unknown-ip.xlsx").unwrap();
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = Iec104ServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
}
eig-domain/src/lib.rs
......@@ -1802,237 +1802,3 @@ fn deserialize_enum_or_unknown<'de, E: EnumFull, D: serde::Deserializer<'de>>(
d.deserialize_any(DeserializeEnumVisitor(PhantomData))
}
\ No newline at end of file
#[cfg(test)]
mod tests {
// use bytes::{Buf, BufMut, BytesMut};
// use protobuf::Message;
// use protobuf::error::WireError;
// use crate::PbMessage;
use crate::from_csv2;
use crate::{from_csv_bytes2, Measurement, PbSetIntPoint, TransportType};
// fn parse_pb_message(buf: &BytesMut) -> ProtobufResult<(usize, PbMessage)> {
// let mut is = CodedInputStream::from_bytes(buf);
// let mut msg = PbMessage::new();
// while !is.eof()? {
// let (field_number, _) = is.read_tag_unpack()?;
// match field_number {
// 1 => {
// let mut topic = String::new();
// is.read_string_into(&mut topic)?;
// msg.set_topic(topic);
// }
// 2 => {
// let mut content = Vec::new();
// is.read_bytes_into(&mut content)?;
// msg.set_content(content);
// break;
// }
// _ => {
// return Err(WireError(WireError::IncorrectTag(
// field_number,
// )));
// }
// };
// }
// Ok((is.pos() as usize, msg))
// }
// #[test]
// fn test_protobuf_parse() {
// let mut msg1 = PbMessage::new();
// msg1.set_topic("t1".to_string());
// msg1.set_content(b"abcdefg".to_vec());
// let mut msg2 = PbMessage::new();
// msg2.set_topic("t2".to_string());
// msg2.set_content(b"123abcdefg".to_vec());
// let bytes1 = msg1.write_to_bytes().unwrap();
// let bytes2 = msg2.write_to_bytes().unwrap();
// let mut buf = BytesMut::with_capacity(bytes1.len() + bytes2.len() + 2);
// buf.extend_from_slice(bytes1.as_slice());
// // 加入一些干扰的数据
// buf.extend_from_slice(b"11");
// let len = bytes2.len();
// // 第二个对象数据不全
// buf.extend_from_slice(&bytes2[0..len - 1]);
// let mut result = Vec::with_capacity(2);
// while !buf.is_empty() {
// match parse_pb_message(&buf) {
// Ok((needed, msg)) => {
// buf.advance(needed);
// result.push(msg);
// }
// Err(WireError(WireError::UnexpectedEof)) => {
// break;
// }
// Err(e) => {
// println!("{:?}", e);
// buf.advance(1);
// }
// }
// }
// // 把第二个对象的数据补全
// buf.put_u8(bytes2[len - 1]);
// while !buf.is_empty() {
// match parse_pb_message(&buf) {
// Ok((needed, msg)) => {
// buf.advance(needed);
// result.push(msg);
// }
// Err(WireError(WireError::UnexpectedEof)) => {
// break;
// }
// Err(e) => {
// println!("{:?}", e);
// buf.advance(1);
// }
// }
// }
// assert_eq!(result.len(), 2);
// assert_eq!(result[0], msg1);
// assert_eq!(result[1], msg2);
// }
#[test]
fn test_proto_serde() {
let mut o = PbSetIntPoint::new();
o.set_pointId(1);
let s = serde_json::to_string(&o).unwrap();
assert!(!s.is_empty());
}
#[test]
fn test_point_from_csv() {
let (points, _) = from_csv2("tests/points-test1.csv", false).unwrap();
assert_eq!(points.len(), 10);
for i in 100001..100009 {
let p = points.get(&i).unwrap();
assert_eq!(p.get_init_discrete(), (i - 100000) as i64);
}
let p = points.get(&100009).unwrap();
assert_eq!(p.get_init_discrete(), -1);
let p = points.get(&100010).unwrap();
assert_eq!(p.get_init_analog(), 10.99);
let mut csv_str = String::new();
let mut i = 1;
for p in points.values() {
csv_str.push_str(i.to_string().as_str());
csv_str.push(',');
csv_str.push_str(p.to_string().as_str());
csv_str.push('\n');
i += 1;
}
let (points2, _) = from_csv_bytes2(csv_str.as_bytes(), false, false).unwrap();
assert_eq!(points, points2);
}
#[test]
fn test_from_csv_bytes() {
let mut p = Measurement {
point_id: 1000,
point_name: "abc".to_string(),
alias_id: "abcd".to_string(),
is_discrete: false,
is_computing_point: false,
expression: "".to_string(),
trans_expr: "".to_string(),
inv_trans_expr: "".to_string(),
change_expr: "".to_string(),
zero_expr: "".to_string(),
data_unit: "".to_string(),
unit: crate::DataUnit::UnitOne,
upper_limit: f64::MAX,
lower_limit: f64::MIN,
alarm_level1_expr: "".to_string(),
alarm_level1: None,
alarm_level2_expr: "".to_string(),
alarm_level2: None,
is_realtime: false,
is_soe: false,
is_remote: false,
init_value: 0,
desc: "".to_string(),
};
let mut s = format!("1,{}", p.to_string());
s.push('\n');
p.point_id = 2000;
p.data_unit = "kV".to_string();
s.push_str(format!("2,{}", p.to_string()).as_str());
s.push('\n');
println!("{}", s);
let (r, _) = from_csv_bytes2(s.into_bytes().as_slice(), false, false).unwrap();
assert_eq!(2, r.len());
assert_eq!(1000, r.get(&1000).unwrap().point_id);
assert_eq!(2000, r.get(&2000).unwrap().point_id);
assert_eq!("kV", r.get(&2000).unwrap().data_unit);
}
#[test]
fn test_parse_radix() {
let s = "0x00010000";
let r = u32::from_str_radix(s.trim_start_matches("0x"), 16).unwrap();
assert_eq!(0x00_01_00_00, r);
let s = "0x00C2000C";
let r = u32::from_str_radix(s.trim_start_matches("0x"), 16).unwrap();
assert_eq!(0x00_C2_00_0C, r);
let bytes = r.to_be_bytes();
println!("{:02x?}", bytes);
}
#[test]
fn test_transport_type() {
assert_eq!(
TransportType::ModbusTcpClient,
TransportType::from("ModbusTcpClient")
);
assert_eq!(
TransportType::ModbusTcpServer,
TransportType::from("ModbusTcpServer")
);
assert_eq!(
TransportType::Iec104Client,
TransportType::from("Iec104Client")
);
assert_eq!(
TransportType::Iec104Server,
TransportType::from("Iec104Server")
);
assert_eq!(TransportType::Unknown, TransportType::from("xx"));
assert_eq!(1, TransportType::ModbusTcpClient as u16);
assert_eq!(2, TransportType::ModbusTcpServer as u16);
assert_eq!(11, TransportType::Iec104Client as u16);
assert_eq!(12, TransportType::Iec104Server as u16);
assert_eq!(100, TransportType::Unknown as u16);
}
#[test]
#[allow(unused_variables)]
fn serde_test() {
// let m = init_discrete_point(100001,0);
// let byte = serde_json::to_vec(&vec![m]).unwrap();
// let m_d = serde_json::from_slice::<Vec<Measurement>>(&byte).unwrap();
let num_f64 = 1.;
let byte = serde_json::to_vec(&num_f64).unwrap();
let num_f64_d = serde_json::from_slice::<f64>(&byte).unwrap();
// let num_f64 = f64::NAN;
// let byte = serde_json::to_vec(&num_f64).unwrap();
// let num_f64_d = serde_json::from_slice::<f64>(&byte).unwrap();
let num_f64 = f64::INFINITY;
let byte = serde_cbor::to_vec(&num_f64).unwrap();
let num_f64_d = serde_cbor::from_slice::<f64>(&byte).unwrap();
}
#[test]
fn test_parse_exp() {
let a = "0.000000e0".to_string();
let b = a.parse::<f64>().unwrap();
println!("{:?}", b);
}
}
eig-domain/src/memory.rs
......@@ -568,28 +568,3 @@ impl MemData {
})
}
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_file() {
let file = "tests/posix-memory-transport-test1.xlsx";
let tp = MemoryPosixTp::from_file(file);
assert!(tp.is_ok());
let tp = tp.unwrap();
assert_eq!("posix-memory-transport-file", tp.path.unwrap());
}
#[test]
fn parse_file_systemv() {
let file = "tests/systemv-memory-transport-test1.xlsx";
let tp = MemorySystemVTp::from_file(file);
let tp = tp.unwrap();
assert_eq!("/", tp.path);
}
}
\ No newline at end of file
eig-domain/src/modbus.rs
......@@ -2221,550 +2221,3 @@ pub fn get_register_count(d: &RegisterData) -> u16 {
count
}
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use std::cmp::Ordering;
use std::collections::HashMap;
use crate::{from_csv, from_csv_bytes, Measurement, PbFile, SerialParity};
use crate::modbus::{
DataType, MbProtocolType, ModbusRtuClientTp, ModbusRtuServerTp, ModbusTcpClientTp,
ModbusTcpServerTp, RegisterType,
};
#[test]
fn test_cmp() {
let t1 = RegisterType::COILS;
let t2 = RegisterType::DISCRETE;
assert_eq!(Some(Ordering::Less), t1.partial_cmp(&t2));
assert!(t1 < t2);
let mut arr = vec![t2, t1];
arr.sort();
assert_eq!(arr, vec![RegisterType::COILS, RegisterType::DISCRETE]);
}
#[test]
fn test_protocol_to_string() {
assert_eq!(MbProtocolType::RTU.to_string(), "RTU");
assert_eq!(MbProtocolType::XA.to_string(), "XA");
assert_eq!(MbProtocolType::ENCAP.to_string(), "ENCAP");
}
#[test]
fn test_certify() {
let r = ModbusTcpServerTp::from_csv("tests/xa-mbd-test1-error.csv");
assert_eq!(r.err().unwrap(), (2, 7));
let r = ModbusTcpClientTp::from_csv("tests/xa-mbc-test1-error.csv");
assert_eq!(r.err().unwrap(), (4, 8));
let r = ModbusRtuClientTp::from_csv("tests/rtu-mbc-test1-error.csv");
assert_eq!(r.err().unwrap(), (14, 17));
}
#[test]
fn test_mbc_from_csv() {
let tp = ModbusTcpClientTp::from_csv("tests/xa-mbc-test1.csv").unwrap();
assert_eq!(tp.name, "测试通道1");
assert_eq!(tp.tcp_server.0, "127.0.0.1");
assert_eq!(tp.tcp_server.1, 5502);
assert_eq!(tp.connections[0].slave_id, 1);
assert_eq!(tp.connections[0].protocol_type, MbProtocolType::XA);
assert_eq!(tp.connections[0].max_read_register_count, 125);
assert_eq!(tp.connections[0].max_read_bit_count, 2000);
assert_eq!(tp.connections[0].default_polling_period_in_milli, 5000);
assert_eq!(tp.connections[0].timeout_in_milli, 1000);
assert_eq!(tp.connections[0].delay_between_requests, 20);
assert_eq!(tp.connections[0].polling_period_to_data.len(), 1);
assert_eq!(tp.connections[0].polling_period_to_data.get(&5000u64).unwrap().len(), 10);
let configure = &tp.connections[0].mb_data_configure;
assert_eq!(configure.len(), 10);
assert_eq!(configure.first().unwrap().point_id, 4001);
assert_eq!(configure.first().unwrap().from, 1);
assert_eq!(configure.first().unwrap().data_type, DataType::Binary);
assert_eq!(configure.first().unwrap().register_type, RegisterType::COILS);
assert!(!configure.first().unwrap().should_new_request);
assert_eq!(configure.first().unwrap().polling_period_in_milli, 5000);
assert_eq!(configure.get(9).unwrap().point_id, 4010);
assert_eq!(configure.get(9).unwrap().from, 10);
assert_eq!(configure.get(9).unwrap().data_type, DataType::Binary);
assert_eq!(configure.get(9).unwrap().register_type, RegisterType::COILS);
assert!(!configure.get(9).unwrap().should_new_request);
assert_eq!(configure.get(9).unwrap().polling_period_in_milli, 5000);
assert_eq!(tp.connections[0].polling_period_to_data.len(), 1);
assert_eq!(tp.connections[0].polling_period_to_data.get(&5000).unwrap().len(), 10);
let (coil, discrete, input, holding)
= tp.connections[0].create_request(5000);
assert_eq!(coil.len(), 1);
let (from, num) = coil.first().unwrap();
assert_eq!(*from, 1);
assert_eq!(*num, 10);
assert_eq!(discrete.len(), 0);
assert_eq!(input.len(), 0);
assert_eq!(holding.len(), 0);
}
#[test]
fn test_mbd_from_csv() {
let tp = ModbusTcpServerTp::from_csv("tests/xa-mbd-test1.csv").unwrap();
assert_eq!(tp.name, "server测试通道");
assert_eq!(tp.connections.len(), 2);
assert_eq!(tp.tcp_server_port, 5502);
let (conn_key, conn) = tp.connections.first().unwrap();
assert_eq!(conn_key, "127.0.0.1/11/测试通道1");
assert_eq!(conn.name, "测试通道1");
assert_eq!(conn.slave_id, 1);
assert_eq!(conn.protocol_type, MbProtocolType::XA);
assert_eq!(conn.max_read_register_count, 125);
assert_eq!(conn.max_read_bit_count, 2000);
assert_eq!(conn.default_polling_period_in_milli, 5000);
assert_eq!(conn.timeout_in_milli, 1000);
assert_eq!(conn.point_id, 4999);
assert_eq!(conn.polling_period_to_data.len(), 1);
assert_eq!(conn.polling_period_to_data.get(&5000u64).unwrap().len(), 10);
assert_eq!(conn.mb_data_configure.len(), 10);
assert_eq!(conn.mb_data_configure.first().unwrap().point_id, 4001);
assert_eq!(conn.mb_data_configure.first().unwrap().from, 1);
assert_eq!(conn.mb_data_configure.first().unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.first().unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.first().unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.first().unwrap().polling_period_in_milli, 5000);
assert_eq!(conn.mb_data_configure.get(9).unwrap().point_id, 4010);
assert_eq!(conn.mb_data_configure.get(9).unwrap().from, 10);
assert_eq!(conn.mb_data_configure.get(9).unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.get(9).unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.get(9).unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.get(9).unwrap().polling_period_in_milli, 5000);
let (conn2_key, connection) = tp.connections.get(1).unwrap();
assert_eq!(conn2_key, "127.0.0.1/23/测试通道2");
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.mb_data_configure.len(), 20);
assert_eq!(connection.point_id, 5999);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_rtu_mbc_wanke_pcs() {
let r = ModbusRtuClientTp::from_csv("tests/rtu-mbc-transport-PCS-20210907.csv");
let tp = r.unwrap();
assert_eq!(tp.connections.len(), 1);
assert_eq!(tp.connections[0].point_id_to_rd.len(), 626);
assert_eq!(tp.connections[0].name, "PCS逆变器");
assert_eq!(tp.connections[0].point_id_to_rd.get(&400133462), Some(&625));
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
let (coil, discrete, input, holding) = tp.connections[0].create_request(2000);
assert_eq!(coil.len(), 0);
assert_eq!(discrete.len(), 4);
assert_eq!(input.len(), 24);
assert_eq!(holding.len(), 15);
let (points, _) = from_csv("tests/points-PCS-20210908.csv").unwrap();
assert_eq!(points.len(), 626);
assert!(points.get(&400133421).is_some());
let ids = tp.get_point_ids();
assert_eq!(ids.len(), 626);
let f = create_point_file(&ids, &points);
let (points, _) = from_csv_bytes(f.fileContent(), false).unwrap();
assert_eq!(points.len(), 626);
}
pub fn create_point_file(ids: &Vec<u64>, all_points: &HashMap<u64, Measurement>) -> PbFile {
let mut points_file = PbFile::new();
// 每个测点估计为300个字节
let mut s = String::with_capacity(ids.len() * 300);
let mut index = 1;
for id in ids {
if let Some(m) = all_points.get(id) {
s.push_str(format!("{},{}\n", index, m.to_string()).as_str());
index += 1;
} else {
log::warn!("Not found: {}", id);
}
}
points_file.set_fileContent(s.into_bytes());
points_file
}
#[test]
fn test_rtu_mbc_from_csv() {
let tp = ModbusRtuClientTp::from_csv("tests/rtu-mbc-test1.csv").unwrap();
assert_eq!(tp.name, "RTU测试通道");
assert_eq!(tp.connections.len(), 2);
assert_eq!(tp.para.baud_rate, 19200);
assert_eq!(tp.para.file_path, "/dev/ttyUSB0");
let conn = tp.connections.first().unwrap();
assert_eq!(conn.name, "测试通道1");
assert_eq!(conn.slave_id, 1);
assert_eq!(conn.protocol_type, MbProtocolType::RTU);
assert_eq!(conn.max_read_register_count, 125);
assert_eq!(conn.max_read_bit_count, 2000);
assert_eq!(conn.default_polling_period_in_milli, 5000);
assert_eq!(conn.timeout_in_milli, 1000);
assert_eq!(conn.polling_period_to_data.len(), 1);
assert_eq!(conn.polling_period_to_data.get(&5000u64).unwrap().len(), 10);
assert_eq!(conn.holding_write_code, Some(16));
assert_eq!(conn.mb_data_configure.len(), 10);
assert_eq!(conn.mb_data_configure.first().unwrap().point_id, 4001);
assert_eq!(conn.mb_data_configure.first().unwrap().from, 1);
assert_eq!(conn.mb_data_configure.first().unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.first().unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.first().unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.first().unwrap().polling_period_in_milli, 5000);
assert_eq!(conn.mb_data_configure.get(9).unwrap().point_id, 4010);
assert_eq!(conn.mb_data_configure.get(9).unwrap().from, 10);
assert_eq!(conn.mb_data_configure.get(9).unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.get(9).unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.get(9).unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.get(9).unwrap().polling_period_in_milli, 5000);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.coil_write_code, None);
assert_eq!(connection.mb_data_configure.len(), 20);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_rtu_mbc_from_csv2() {
let tp = ModbusRtuClientTp::from_csv("tests/rtu-mbc-test2.csv").unwrap();
assert_eq!(tp.name, "RTU测试通道");
assert_eq!(tp.connections.len(), 2);
assert_eq!(tp.para.baud_rate, 19200);
assert_eq!(tp.para.file_path, "/dev/ttyUSB0");
assert_eq!(tp.para.data_bits, 10);
assert_eq!(tp.para.stop_bits, 2);
assert_eq!(tp.para.parity, SerialParity::Odd);
assert_eq!(tp.para.delay_between_requests, 20);
let conn = tp.connections.first().unwrap();
assert_eq!(conn.name, "测试通道1");
assert_eq!(conn.slave_id, 1);
assert_eq!(conn.protocol_type, MbProtocolType::RTU);
assert_eq!(conn.max_read_register_count, 125);
assert_eq!(conn.max_read_bit_count, 2000);
assert_eq!(conn.default_polling_period_in_milli, 5000);
assert_eq!(conn.timeout_in_milli, 1000);
assert_eq!(conn.polling_period_to_data.len(), 1);
assert_eq!(conn.polling_period_to_data.get(&5000u64).unwrap().len(), 10);
assert_eq!(conn.mb_data_configure.len(), 10);
assert_eq!(conn.mb_data_configure.first().unwrap().point_id, 4001);
assert_eq!(conn.mb_data_configure.first().unwrap().from, 1);
assert_eq!(conn.mb_data_configure.first().unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.first().unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.first().unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.first().unwrap().polling_period_in_milli, 5000);
assert_eq!(conn.mb_data_configure.get(9).unwrap().point_id, 4010);
assert_eq!(conn.mb_data_configure.get(9).unwrap().from, 10);
assert_eq!(conn.mb_data_configure.get(9).unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.get(9).unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.get(9).unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.get(9).unwrap().polling_period_in_milli, 5000);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.mb_data_configure.len(), 20);
assert_eq!(connection.mb_data_configure.first().unwrap().point_id, 5001);
assert_eq!(connection.mb_data_configure.first().unwrap().from, 1);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
let tp = ModbusRtuClientTp::from_csv("tests/rtu-mbc-test3.csv").unwrap();
assert_eq!(tp.name, "RTU测试通道");
assert_eq!(conn.name, "测试通道1");
assert_eq!(conn.slave_id, 1);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.slave_id, 1);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_rtu_mbc_from_csv3() {
let tp = ModbusRtuClientTp::from_csv("tests/rtu-mbc-transport-shtb-20220111.csv").unwrap();
let connection = tp.connections.first().unwrap();
assert_eq!(connection.name, "园区负荷表");
assert_eq!(connection.slave_id, 26);
assert_eq!(connection.mb_data_configure.len(), 5);
assert_eq!(connection.mb_data_configure[0].point_id, 100010033026120);
assert_eq!(connection.mb_data_configure[4].point_id, 1000100330261001);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "万克结算表");
assert_eq!(connection.mb_data_configure.len(), 17);
assert_eq!(connection.mb_data_configure[0].point_id, 10001003300193);
assert_eq!(connection.mb_data_configure[16].point_id, 100010033001128);
let connection = tp.connections.get(2).unwrap();
assert_eq!(connection.name, "温控仪");
assert_eq!(connection.mb_data_configure.len(), 5);
assert_eq!(connection.mb_data_configure[0].point_id, 1000100330040);
assert_eq!(connection.mb_data_configure[4].point_id, 1000100330044);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuClientTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_rtu_mbd_from_csv() {
let tp = ModbusRtuServerTp::from_csv("tests/rtu-mbd-test1.csv").unwrap();
assert_eq!(tp.name, "测试通道1");
assert_eq!(tp.para.baud_rate, 19200);
assert_eq!(tp.para.file_path, "/dev/ttyUSB0");
assert_eq!(tp.para.data_bits, 8); // 默认值
assert_eq!(tp.para.stop_bits, 1); // 默认值
assert_eq!(tp.para.parity, SerialParity::None); // 默认值
let conn = &tp.connection;
assert_eq!(conn.slave_id, 1);
assert_eq!(conn.protocol_type, MbProtocolType::RTU);
assert_eq!(conn.max_read_register_count, 125);
assert_eq!(conn.max_read_bit_count, 2000);
assert_eq!(conn.default_polling_period_in_milli, 5000);
assert_eq!(conn.timeout_in_milli, 1000);
assert_eq!(conn.polling_period_to_data.len(), 1);
assert_eq!(conn.polling_period_to_data.get(&5000u64).unwrap().len(), 10);
assert_eq!(conn.mb_data_configure.len(), 10);
assert_eq!(conn.mb_data_configure.first().unwrap().point_id, 4001);
assert_eq!(conn.mb_data_configure.first().unwrap().from, 1);
assert_eq!(conn.mb_data_configure.first().unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.first().unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.first().unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.first().unwrap().polling_period_in_milli, 5000);
assert_eq!(conn.mb_data_configure.get(9).unwrap().point_id, 4010);
assert_eq!(conn.mb_data_configure.get(9).unwrap().from, 10);
assert_eq!(conn.mb_data_configure.get(9).unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.get(9).unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.get(9).unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.get(9).unwrap().polling_period_in_milli, 5000);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_rtu_mbd_from_csv2() {
let tp = ModbusRtuServerTp::from_csv("tests/rtu-mbd-test2.csv").unwrap();
assert_eq!(tp.name, "测试通道1");
assert_eq!(tp.para.baud_rate, 19200);
assert_eq!(tp.para.file_path, "/dev/ttyUSB0");
assert_eq!(tp.para.data_bits, 10);
assert_eq!(tp.para.stop_bits, 2);
assert_eq!(tp.para.parity, SerialParity::Odd);
let conn = &tp.connection;
assert_eq!(conn.slave_id, 1);
assert_eq!(conn.protocol_type, MbProtocolType::RTU);
assert_eq!(conn.max_read_register_count, 125);
assert_eq!(conn.max_read_bit_count, 2000);
assert_eq!(conn.default_polling_period_in_milli, 5000);
assert_eq!(conn.timeout_in_milli, 1000);
assert_eq!(conn.polling_period_to_data.len(), 1);
assert_eq!(conn.polling_period_to_data.get(&5000u64).unwrap().len(), 10);
assert_eq!(conn.mb_data_configure.len(), 10);
assert_eq!(conn.mb_data_configure.first().unwrap().point_id, 4001);
assert_eq!(conn.mb_data_configure.first().unwrap().from, 1);
assert_eq!(conn.mb_data_configure.first().unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.first().unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.first().unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.first().unwrap().polling_period_in_milli, 5000);
assert_eq!(conn.mb_data_configure.get(9).unwrap().point_id, 4010);
assert_eq!(conn.mb_data_configure.get(9).unwrap().from, 10);
assert_eq!(conn.mb_data_configure.get(9).unwrap().data_type, DataType::Binary);
assert_eq!(conn.mb_data_configure.get(9).unwrap().register_type, RegisterType::COILS);
assert!(!conn.mb_data_configure.get(9).unwrap().should_new_request);
assert_eq!(conn.mb_data_configure.get(9).unwrap().polling_period_in_milli, 5000);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_rtu_mbd_from_csv3() {
let tp = ModbusRtuServerTp::from_csv("tests/rtu-mbd-test3.csv").unwrap();
assert_eq!(tp.para.baud_rate, 9600);
assert_eq!(tp.para.file_path, "/dev/ttyUSB0");
assert_eq!(tp.para.data_bits, 8);
assert_eq!(tp.para.stop_bits, 1);
assert_eq!(tp.para.parity, SerialParity::None);
assert_eq!(tp.connection.slave_id, 1);
assert_eq!(tp.connection.protocol_type, MbProtocolType::RTU);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusRtuServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_mbc_encap_from_csv() {
let tp = ModbusTcpClientTp::from_csv("tests/encap-mbc-transport-10.csv").unwrap();
let (coil, discrete, input, holding) = tp.connections[0].create_request(5000);
assert_eq!(coil.len(), 1);
assert_eq!(discrete.len(), 1);
assert_eq!(input.len(), 1);
assert_eq!(holding.len(), 1);
let (from, num) = coil.first().unwrap();
assert_eq!(*from, 1);
assert_eq!(*num, 2);
let (from, num) = discrete.first().unwrap();
assert_eq!(*from, 3);
assert_eq!(*num, 2);
let (from, num) = input.first().unwrap();
assert_eq!(*from, 8);
assert_eq!(*num, 3);
let (from, num) = holding.first().unwrap();
assert_eq!(*from, 5);
assert_eq!(*num, 3);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpClientTp::from_csv_bytes2(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_mbc_encap_from_csv_202105() {
let tp = ModbusTcpClientTp::from_csv("tests/encap-mbc-transport-slave1.csv").unwrap();
let (coil, discrete, input, holding) = tp.connections[0].create_request(5000);
assert_eq!(coil.len(), 1);
assert_eq!(discrete.len(), 1);
assert_eq!(input.len(), 1);
assert_eq!(holding.len(), 1);
let (from, num) = coil.first().unwrap();
assert_eq!(*from, 1);
assert_eq!(*num, 10);
let (from, num) = discrete.first().unwrap();
assert_eq!(*from, 101);
assert_eq!(*num, 10);
let (from, num) = input.first().unwrap();
assert_eq!(*from, 201);
assert_eq!(*num, 13);
let (from, num) = holding.first().unwrap();
assert_eq!(*from, 301);
assert_eq!(*num, 54);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpClientTp::from_csv_bytes2(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_mbc_xa_from_csv_20211110() {
let tp = ModbusTcpClientTp::from_csv("tests/xa-mbc-transport-py.csv").unwrap();
let (coil, discrete, input, holding) = tp.connections[0].create_request(2000);
assert_eq!(coil.len(), 0);
assert_eq!(discrete.len(), 0);
assert_eq!(input.len(), 0);
assert_eq!(holding.len(), 7);
let (from, num) = holding.first().unwrap();
assert_eq!(*from, 1);
assert_eq!(*num, 124);
let (from, num) = holding.get(6).unwrap();
assert_eq!(*from, 745);
assert_eq!(*num, 64);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpClientTp::from_csv_bytes2(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_tcp_mbc() {
let tp = ModbusTcpClientTp::from_csv2("tests/tcp-mbc-test1.csv").unwrap();
let connection = tp.connections.first().unwrap();
assert_eq!(connection.name, "测试通道1");
assert_eq!(connection.slave_id, 1);
assert_eq!(connection.mb_data_configure.len(), 10);
assert_eq!(connection.mb_data_configure[0].point_id, 4001);
assert_eq!(connection.mb_data_configure[4].point_id, 4005);
assert_eq!(connection.delay_between_requests, 30);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.slave_id, 2);
assert_eq!(connection.mb_data_configure.len(), 20);
assert_eq!(connection.mb_data_configure[0].point_id, 5001);
assert_eq!(connection.mb_data_configure[16].point_id, 5106);
assert_eq!(connection.delay_between_requests, 0);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpClientTp::from_csv_bytes2(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
let tp = ModbusTcpClientTp::from_csv2("tests/tcp-mbc-test2.csv").unwrap();
let connection = tp.connections.first().unwrap();
assert_eq!(connection.name, "测试通道1");
assert_eq!(connection.slave_id, 1);
let connection = tp.connections.get(1).unwrap();
assert_eq!(connection.name, "测试通道2");
assert_eq!(connection.slave_id, 1);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpClientTp::from_csv_bytes2(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_encap_mbc_from_csv() {
let tp = ModbusTcpClientTp::from_csv("tests/encap-mbc-test1.csv").unwrap();
let connection = tp.connections.first().unwrap();
assert_eq!(connection.name, "空调");
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpClientTp::from_csv_bytes2(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_export_mbd_model() {
let tp = ModbusTcpServerTp::from_file("tests/tcp-mbd-labview.xlsx").unwrap();
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_export_mbc_model() {
let tp = ModbusTcpClientTp::from_file2("tests/tcp-mbc-transport-5000-1.xlsx").unwrap();
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpClientTp::from_csv_bytes2(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_export_mbd_unknown_ip() {
let tp = ModbusTcpServerTp::from_file("tests/tcp-mbd-unknown-ip.xlsx").unwrap();
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = ModbusTcpServerTp::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
}
eig-domain/src/mqtt.rs
......@@ -508,120 +508,3 @@ pub fn merge_json(tags: &[String], values: &[Value]) -> Value {
}
result
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use serde_json::{json, Value};
use crate::from_file;
use crate::mqtt::{merge_json, MqttTransport, split_json};
use crate::utils::check_mqtt_transport;
#[test]
fn test_parse_mqtt_csv() {
let tp = MqttTransport::from_csv("tests/mqtt-test1.csv").unwrap();
assert_eq!(tp.name, "Mqtt测试通道");
assert_eq!(tp.mqtt_broker, ("127.0.0.1".to_string(), 1883u16));
assert_eq!(tp.read_topic, "gwIn/read");
assert_eq!(tp.write_topic, "gwOut/write");
assert_eq!(tp.point_id, 9001);
assert_eq!(tp.point_ids.len(), 10);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = MqttTransport::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
let tp = MqttTransport::from_csv("tests/mqtt-test2.csv").unwrap();
assert_eq!(tp.user_name, Some(String::from("admin")));
assert_eq!(tp.user_password, Some(String::from("admin")));
assert!(tp.is_json);
assert!(tp.is_transfer);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = MqttTransport::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
let tp = MqttTransport::from_csv("tests/mqtt-test3.csv").unwrap();
assert_eq!(tp.point_ids.len(), 4);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = MqttTransport::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
let tp = MqttTransport::from_csv("tests/mqtt-transport-db1.csv").unwrap();
assert_eq!(tp.point_ids.len(), 6);
let s = tp.export_csv(&HashMap::with_capacity(0));
let tp2 = MqttTransport::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
}
#[test]
fn test_export_mqtt_model() {
let tp1 = MqttTransport::from_csv("tests/mqtt-test1.csv").unwrap();
let tp1_export = tp1.export_csv(&HashMap::with_capacity(0));
let tp1_parse_from_export = MqttTransport::from_csv_bytes(tp1_export.as_bytes());
assert_eq!(tp1_parse_from_export, Ok(tp1));
let tp2 = MqttTransport::from_csv("tests/mqtt-test2.csv").unwrap();
let tp2_export = tp2.export_csv(&HashMap::with_capacity(0));
let tp2_parse_from_export = MqttTransport::from_csv_bytes(tp2_export.as_bytes());
assert_eq!(tp2_parse_from_export, Ok(tp2));
}
#[test]
fn test_parse_with_custom_json() {
let v1 = json!({
"code": 200,
"success": true,
"payload": {
"features": [
"serde",
"json"
],
"homepage": null
}
});
let map = split_json(&v1);
let keys: Vec<String> = map.keys().cloned().collect();
let values: Vec<Value> = map.values().cloned().collect();
let v2 = merge_json(&keys, &values);
assert_eq!(v1, v2);
let tp = MqttTransport::from_csv("tests/mqtt-test4.csv").unwrap();
let s = tp.export_csv(&HashMap::with_capacity(0));
// println!("{}", s);
let tp2 = MqttTransport::from_csv_bytes(s.as_bytes()).unwrap();
assert_eq!(tp, tp2);
// println!("{:?}", tp);
assert_eq!(tp.point_ids.len(), 10);
assert_eq!(tp.json_filters.unwrap().len(), 1);
assert_eq!(tp.json_tags.unwrap().len(), 3);
}
#[test]
fn test_custom_json2() {
let tp1 = MqttTransport::from_csv("tests/mqtt-test5.csv").unwrap();
assert!(tp1.json_tags.is_some());
assert_eq!(1, tp1.json_tags.as_ref().unwrap().len());
let tags = tp1.json_tags.as_ref().unwrap().get("[0]");
assert!(tags.is_some());
assert_eq!(10, tags.unwrap().len());
let tp1_export = tp1.export_csv(&HashMap::with_capacity(0));
let tp1_parse_from_export = MqttTransport::from_csv_bytes(tp1_export.as_bytes());
assert_eq!(tp1_parse_from_export, Ok(tp1));
let r = MqttTransport::from_csv("tests/mqtt-test6.csv");
assert_eq!(r, Err((2, 6)));
}
#[test]
fn test_custom_json3() {
let tp1 = MqttTransport::from_file("tests/mqtt-transport-nb1.xlsx");
assert!(tp1.is_ok());
let tp1 = tp1.unwrap();
assert!(tp1.json_tags.is_some());
let (points, _) = from_file("tests/points-nb1.xlsx").unwrap();
let r = check_mqtt_transport(&points, &tp1);
assert_eq!(r, Ok(()));
let tp1_export = tp1.export_csv(&HashMap::with_capacity(0));
// println!("{}", tp1_export);
let tp1_parse_from_export = MqttTransport::from_csv_bytes(tp1_export.as_bytes());
assert_eq!(tp1_parse_from_export, Ok(tp1));
}
}
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论