OpenLogics/MewtocolNet
1
0
Fork 0
mirror of https://github.com/OpenLogics/MewtocolNet.git synced 2025-12-06 03:01:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Further implementation

Browse Source 
- added new parsing method
This commit is contained in:
Felix Weiß
2023-06-26 19:13:04 +02:00
parent b48f86d23d
commit 7be52efb7e
36 changed files with 1181 additions and 1004 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
MewtocolTests/TestRegisterBuilder.cs
View File

@@ -16,32 +16,32 @@ public class TestRegisterBuilder {
this.output = output;
}
[Fact(DisplayName = "Parsing as BRegister List (Phyiscal Outputs)")]
[Fact(DisplayName = "Parsing as Bool Register List (Phyiscal Outputs)")]
public void TestParsingBRegisterY() {
var tests = new Dictionary<string, IRegister>() {
{"Y0", new BRegister(IOType.Y)},
{"Y1", new BRegister(IOType.Y, 0x1)},
{"Y2", new BRegister(IOType.Y, 0x2)},
{"Y3", new BRegister(IOType.Y, 0x3)},
{"Y4", new BRegister(IOType.Y, 0x4)},
{"Y5", new BRegister(IOType.Y, 0x5)},
{"Y6", new BRegister(IOType.Y, 0x6)},
{"Y7", new BRegister(IOType.Y, 0x7)},
{"Y8", new BRegister(IOType.Y, 0x8)},
{"Y9", new BRegister(IOType.Y, 0x9)},
{"Y0", new BoolRegister(IOType.Y)},
{"Y1", new BoolRegister(IOType.Y, 0x1)},
{"Y2", new BoolRegister(IOType.Y, 0x2)},
{"Y3", new BoolRegister(IOType.Y, 0x3)},
{"Y4", new BoolRegister(IOType.Y, 0x4)},
{"Y5", new BoolRegister(IOType.Y, 0x5)},
{"Y6", new BoolRegister(IOType.Y, 0x6)},
{"Y7", new BoolRegister(IOType.Y, 0x7)},
{"Y8", new BoolRegister(IOType.Y, 0x8)},
{"Y9", new BoolRegister(IOType.Y, 0x9)},
{"YA", new BRegister(IOType.Y, 0xA)},
{"YB", new BRegister(IOType.Y, 0xB)},
{"YC", new BRegister(IOType.Y, 0xC)},
{"YD", new BRegister(IOType.Y, 0xD)},
{"YE", new BRegister(IOType.Y, 0xE)},
{"YF", new BRegister(IOType.Y, 0xF)},
{"YA", new BoolRegister(IOType.Y, 0xA)},
{"YB", new BoolRegister(IOType.Y, 0xB)},
{"YC", new BoolRegister(IOType.Y, 0xC)},
{"YD", new BoolRegister(IOType.Y, 0xD)},
{"YE", new BoolRegister(IOType.Y, 0xE)},
{"YF", new BoolRegister(IOType.Y, 0xF)},
{"Y1A", new BRegister(IOType.Y, 0xA, 1)},
{"Y10B", new BRegister(IOType.Y, 0xB, 10)},
{"Y109C", new BRegister(IOType.Y, 0xC, 109)},
{"Y1A", new BoolRegister(IOType.Y, 0xA, 1)},
{"Y10B", new BoolRegister(IOType.Y, 0xB, 10)},
{"Y109C", new BoolRegister(IOType.Y, 0xC, 109)},
};
@@ -49,32 +49,32 @@ public class TestRegisterBuilder {
}
[Fact(DisplayName = "Parsing as BRegister List (Phyiscal Inputs)")]
[Fact(DisplayName = "Parsing as Bool Register List (Phyiscal Inputs)")]
public void TestParsingBRegisterX() {
var tests = new Dictionary<string, IRegister>() {
{"X0", new BRegister(IOType.X)},
{"X1", new BRegister(IOType.X, 0x1)},
{"X2", new BRegister(IOType.X, 0x2)},
{"X3", new BRegister(IOType.X, 0x3)},
{"X4", new BRegister(IOType.X, 0x4)},
{"X5", new BRegister(IOType.X, 0x5)},
{"X6", new BRegister(IOType.X, 0x6)},
{"X7", new BRegister(IOType.X, 0x7)},
{"X8", new BRegister(IOType.X, 0x8)},
{"X9", new BRegister(IOType.X, 0x9)},
{"X0", new BoolRegister(IOType.X)},
{"X1", new BoolRegister(IOType.X, 0x1)},
{"X2", new BoolRegister(IOType.X, 0x2)},
{"X3", new BoolRegister(IOType.X, 0x3)},
{"X4", new BoolRegister(IOType.X, 0x4)},
{"X5", new BoolRegister(IOType.X, 0x5)},
{"X6", new BoolRegister(IOType.X, 0x6)},
{"X7", new BoolRegister(IOType.X, 0x7)},
{"X8", new BoolRegister(IOType.X, 0x8)},
{"X9", new BoolRegister(IOType.X, 0x9)},
{"XA", new BRegister(IOType.X, 0xA)},
{"XB", new BRegister(IOType.X, 0xB)},
{"XC", new BRegister(IOType.X, 0xC)},
{"XD", new BRegister(IOType.X, 0xD)},
{"XE", new BRegister(IOType.X, 0xE)},
{"XF", new BRegister(IOType.X, 0xF)},
{"XA", new BoolRegister(IOType.X, 0xA)},
{"XB", new BoolRegister(IOType.X, 0xB)},
{"XC", new BoolRegister(IOType.X, 0xC)},
{"XD", new BoolRegister(IOType.X, 0xD)},
{"XE", new BoolRegister(IOType.X, 0xE)},
{"XF", new BoolRegister(IOType.X, 0xF)},
{"X1A", new BRegister(IOType.X, 0xA, 1)},
{"X10B", new BRegister(IOType.X, 0xB, 10)},
{"X109C", new BRegister(IOType.X, 0xC, 109)},
{"X1A", new BoolRegister(IOType.X, 0xA, 1)},
{"X10B", new BoolRegister(IOType.X, 0xB, 10)},
{"X109C", new BoolRegister(IOType.X, 0xC, 109)},
};
@@ -82,35 +82,35 @@ public class TestRegisterBuilder {
}
[Fact(DisplayName = "Parsing as BRegister List (Internal Relay)")]
[Fact(DisplayName = "Parsing as Bool Register List (Internal Relay)")]
public void TestParsingBRegisterR() {
var tests = new Dictionary<string, IRegister>() {
{"R0", new BRegister(IOType.R)},
{"R1", new BRegister(IOType.R, 0x1)},
{"R2", new BRegister(IOType.R, 0x2)},
{"R3", new BRegister(IOType.R, 0x3)},
{"R4", new BRegister(IOType.R, 0x4)},
{"R5", new BRegister(IOType.R, 0x5)},
{"R6", new BRegister(IOType.R, 0x6)},
{"R7", new BRegister(IOType.R, 0x7)},
{"R8", new BRegister(IOType.R, 0x8)},
{"R9", new BRegister(IOType.R, 0x9)},
{"R0", new BoolRegister(IOType.R)},
{"R1", new BoolRegister(IOType.R, 0x1)},
{"R2", new BoolRegister(IOType.R, 0x2)},
{"R3", new BoolRegister(IOType.R, 0x3)},
{"R4", new BoolRegister(IOType.R, 0x4)},
{"R5", new BoolRegister(IOType.R, 0x5)},
{"R6", new BoolRegister(IOType.R, 0x6)},
{"R7", new BoolRegister(IOType.R, 0x7)},
{"R8", new BoolRegister(IOType.R, 0x8)},
{"R9", new BoolRegister(IOType.R, 0x9)},
{"RA", new BRegister(IOType.R, 0xA)},
{"RB", new BRegister(IOType.R, 0xB)},
{"RC", new BRegister(IOType.R, 0xC)},
{"RD", new BRegister(IOType.R, 0xD)},
{"RE", new BRegister(IOType.R, 0xE)},
{"RF", new BRegister(IOType.R, 0xF)},
{"RA", new BoolRegister(IOType.R, 0xA)},
{"RB", new BoolRegister(IOType.R, 0xB)},
{"RC", new BoolRegister(IOType.R, 0xC)},
{"RD", new BoolRegister(IOType.R, 0xD)},
{"RE", new BoolRegister(IOType.R, 0xE)},
{"RF", new BoolRegister(IOType.R, 0xF)},
{"R1A", new BRegister(IOType.R, 0xA, 1)},
{"R10B", new BRegister(IOType.R, 0xB, 10)},
{"R109C", new BRegister(IOType.R, 0xC, 109)},
{"R1000", new BRegister(IOType.R, 0x0, 100)},
{"R511", new BRegister(IOType.R, 0x0, 511)},
{"R511A", new BRegister(IOType.R, 0xA, 511)},
{"R1A", new BoolRegister(IOType.R, 0xA, 1)},
{"R10B", new BoolRegister(IOType.R, 0xB, 10)},
{"R109C", new BoolRegister(IOType.R, 0xC, 109)},
{"R1000", new BoolRegister(IOType.R, 0x0, 100)},
{"R511", new BoolRegister(IOType.R, 0x0, 511)},
{"R511A", new BoolRegister(IOType.R, 0xA, 511)},
};
@@ -126,7 +126,7 @@ public class TestRegisterBuilder {
output.WriteLine($"Expected: {item.Key}");
var built = RegBuilder.FromPlcRegName(item.Key).AsPlcType(PlcVarType.BOOL).Build();
var built = RegBuilder.Factory.FromPlcRegName(item.Key).AsPlcType(PlcVarType.BOOL).Build();
output.WriteLine($"{(built?.ToString(true) ?? "null")}\n");
Assert.Equivalent(item.Value, built);
@@ -141,63 +141,75 @@ public class TestRegisterBuilder {
}
[Fact(DisplayName = "Parsing as BRegister (Casted)")]
[Fact(DisplayName = "Parsing as Bool Register (Casted)")]
public void TestRegisterBuildingBoolCasted () {
var expect = new BRegister(IOType.R, 0x1, 0);
var expect2 = new BRegister(IOType.Y, 0xA, 103);
var expect = new BoolRegister(IOType.R, 0x1, 0);
var expect2 = new BoolRegister(IOType.Y, 0xA, 103);
Assert.Equivalent(expect, RegBuilder.FromPlcRegName("R1").AsPlcType(PlcVarType.BOOL).Build());
Assert.Equivalent(expect, RegBuilder.FromPlcRegName("R1").AsType<bool>().Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("R1").AsPlcType(PlcVarType.BOOL).Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("R1").AsType<bool>().Build());
Assert.Equivalent(expect2, RegBuilder.FromPlcRegName("Y103A").AsPlcType(PlcVarType.BOOL).Build());
Assert.Equivalent(expect2, RegBuilder.FromPlcRegName("Y103A").AsType<bool>().Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("Y103A").AsPlcType(PlcVarType.BOOL).Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("Y103A").AsType<bool>().Build());
}
[Fact(DisplayName = "Parsing as BRegister (Auto)")]
[Fact(DisplayName = "Parsing as Bool Register (Auto)")]
public void TestRegisterBuildingBoolAuto () {
var expect = new BRegister(IOType.R, 0x1, 0);
var expect2 = new BRegister(IOType.Y, 0xA, 103);
var expect = new BoolRegister(IOType.R, 0x1, 0);
var expect2 = new BoolRegister(IOType.Y, 0xA, 103);
Assert.Equivalent(expect, RegBuilder.FromPlcRegName("R1").Build());
Assert.Equivalent(expect, RegBuilder.FromPlcRegName("R1").Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("R1").Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("R1").Build());
Assert.Equivalent(expect2, RegBuilder.FromPlcRegName("Y103A").Build());
Assert.Equivalent(expect2, RegBuilder.FromPlcRegName("Y103A").Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("Y103A").Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("Y103A").Build());
}
[Fact(DisplayName = "Parsing as NRegister (Casted)")]
[Fact(DisplayName = "Parsing as Number Register (Casted)")]
public void TestRegisterBuildingNumericCasted() {
var expect = new NRegister<short>(303, null);
var expect2 = new NRegister<int>(10002, null);
var expect3 = new NRegister<TimeSpan>(400, null);
var expect = new NumberRegister<short>(303, null);
var expect2 = new NumberRegister<int>(10002, null);
var expect3 = new NumberRegister<TimeSpan>(400, null);
//var expect4 = new NRegister<TimeSpan>(103, null, true);
Assert.Equivalent(expect, RegBuilder.FromPlcRegName("DT303").AsPlcType(PlcVarType.INT).Build());
Assert.Equivalent(expect, RegBuilder.FromPlcRegName("DT303").AsType<short>().Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").AsPlcType(PlcVarType.INT).Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").AsType<short>().Build());
Assert.Equivalent(expect2, RegBuilder.FromPlcRegName("DDT10002").AsPlcType(PlcVarType.DINT).Build());
Assert.Equivalent(expect2, RegBuilder.FromPlcRegName("DDT10002").AsType<int>().Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("DDT10002").AsPlcType(PlcVarType.DINT).Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("DDT10002").AsType<int>().Build());
Assert.Equivalent(expect3, RegBuilder.FromPlcRegName("DDT400").AsPlcType(PlcVarType.TIME).Build());
Assert.Equivalent(expect3, RegBuilder.FromPlcRegName("DDT400").AsType<TimeSpan>().Build());
Assert.Equivalent(expect3, RegBuilder.Factory.FromPlcRegName("DDT400").AsPlcType(PlcVarType.TIME).Build());
Assert.Equivalent(expect3, RegBuilder.Factory.FromPlcRegName("DDT400").AsType<TimeSpan>().Build());
//Assert.Equivalent(expect4, RegBuilder.FromPlcRegName("DT103").AsType<BitArray>().Build());
}
[Fact(DisplayName = "Parsing as NRegister (Auto)")]
[Fact(DisplayName = "Parsing as Number Register (Auto)")]
public void TestRegisterBuildingNumericAuto() {
var expect = new NRegister<short>(303, null);
var expect2 = new NRegister<int>(10002, null);
var expect = new NumberRegister<short>(303, null);
var expect2 = new NumberRegister<int>(10002, null);
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("DDT10002").Build());
}
[Fact(DisplayName = "Parsing as Bytes Register (Casted)")]
public void TestRegisterBuildingByteRangeCasted() {
var expect = new BytesRegister<byte[]>(303, 5);
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").AsPlcType(PlcVarType.INT).Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").AsType<short>().Build());
Assert.Equivalent(expect, RegBuilder.FromPlcRegName("DT303").Build());
Assert.Equivalent(expect2, RegBuilder.FromPlcRegName("DDT10002").Build());
}