winzer/elwig
2
1
Fork 0
Code Issues 11 Pull Requests Actions Releases 46 Activity

Tests: Add UnitTests folder
All checks were successful
Test / Run tests (push) Successful in 2m24s
Details

Browse Source
This commit is contained in:
Lorenz Stechauner
2025-06-03 20:57:53 +02:00
parent 623f55f5b0
commit 3493ff6df1
31 changed files with 31 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1038
Tests/UnitTests/HelperTests/BillingDataTest.cs Normal file
View File

File diff suppressed because it is too large Load Diff

355
Tests/UnitTests/HelperTests/BillingTest.cs Normal file
View File

@ -0,0 +1,355 @@
using Elwig.Helpers;
using Elwig.Helpers.Billing;
using Microsoft.Data.Sqlite;
using System.Reflection;
namespace Tests.UnitTests.HelperTests {
[TestFixture]
public class BillingTest {
private const int Year1 = 2020, Year2 = 2021;
private const int MgNr1 = 101, MgNr2 = 102, MgNr3 = 103, MgNr4 = 104;
private const decimal
GV_ungeb = 0.50m,
GV_geb = 0.60m,
GVB_ungeb = 0.54m,
GVB_geb = 0.64m,
GVK_ungeb = 0.61m,
GVK_geb = 0.71m,
WEI = 0.10m;
private SqliteConnection? Connection;
[OneTimeSetUp]
public async Task SetupDatabase() {
Connection = await AppDbContext.ConnectAsync();
await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.BillingInsert.sql");
}
[OneTimeTearDown]
public async Task TeardownDatabase() {
if (Connection == null) return;
await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.BillingDelete.sql");
await Connection.DisposeAsync();
Connection = null;
}
[SetUp]
public async Task CreatePaymentVariant() {
var json = """
{
"mode": "elwig",
"version": 1,
"payment": {
"GV": "curve:0",
"GV-B": "curve:1",
"GV/K": "curve:2"
},
"quality": {"WEI": 0.1},
"curves": [{
"id": 0,
"mode": "oe",
"data": {"15kmw": 0.5},
"geb": 0.1
}, {
"id": 1,
"mode": "oe",
"data": {"15kmw": 0.54},
"geb": 0.1
}, {
"id": 2,
"mode": "oe",
"data": {"15kmw": 0.61},
"geb": 0.1
}]
}
""";
await InsertPaymentVariant(Year1, 1, json);
await InsertPaymentVariant(Year2, 1, json);
}
[TearDown]
public async Task CleanupDatabasePayment() {
if (Connection == null) return;
await AppDbContext.ExecuteBatch(Connection, """
DELETE FROM credit;
DELETE FROM payment_variant;
DELETE FROM delivery_part_bucket;
""");
}
private Task<Dictionary<string, AreaComBucket>> GetMemberAreaCommitmentBuckets(int year, int mgnr) {
using var ctx = new AppDbContext();
return ctx.GetMemberAreaCommitmentBuckets(year, mgnr, Connection);
}
private Task<Dictionary<string, int>> GetMemberDeliveryBuckets(int year, int mgnr) {
using var ctx = new AppDbContext();
return ctx.GetMemberDeliveryBuckets(year, mgnr, Connection);
}
private Task<Dictionary<string, int>> GetMemberPaymentBuckets(int year, int mgnr) {
using var ctx = new AppDbContext();
return ctx.GetMemberPaymentBuckets(year, mgnr, Connection);
}
private async Task<Dictionary<(string, string), (int, decimal)>> GetMemberDeliveryPrices(int year, int mgnr) {
var buckets = new Dictionary<(string, string), (int, decimal)>();
using (var cmd = Connection!.CreateCommand()) {
cmd.CommandText = $"""
SELECT lsnr || '/' || d.dpnr, d.sortid || b.discr, b.value, p.price
FROM v_delivery d
LEFT JOIN payment_delivery_part_bucket p ON (p.year, p.did, p.dpnr) = (d.year, d.did, d.dpnr)
LEFT JOIN delivery_part_bucket b ON (b.year, b.did, b.dpnr, b.bktnr) = (p.year, p.did, p.dpnr, p.bktnr)
WHERE d.year = {year} AND mgnr = {mgnr}
""";
using var reader = await cmd.ExecuteReaderAsync();
while (await reader.ReadAsync()) {
var lsnr = reader.GetString(0);
var bucket = reader.GetString(1);
buckets[(lsnr, bucket)] = (reader.GetInt32(2), Utils.DecFromDb(reader.GetInt32(3), 4));
}
}
return buckets;
}
private Task InsertPaymentVariant(int year, int avnr, string data) {
return AppDbContext.ExecuteBatch(Connection!, $"""
INSERT INTO payment_variant (year, avnr, name, date, transfer_date, test_variant, calc_time, data)
VALUES ({year}, {avnr}, 'Test', '2021-01-15', NULL, TRUE, NULL, '{data}');
""");
}
[Test]
public async Task Test_01_NoActiveAreaComs() {
int mgnr = MgNr1, year = Year1;
var areaCom = await GetMemberAreaCommitmentBuckets(year, mgnr);
Assert.That(areaCom, Is.Empty);
var delivery = await GetMemberDeliveryBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(delivery, Has.Count.EqualTo(3));
Assert.That(delivery["GV"], Is.EqualTo(16_000));
Assert.That(delivery["GV_"], Is.EqualTo( 1_000));
Assert.That(delivery["GVK"], Is.EqualTo( 4_000));
});
BillingVariant b = new(year, 1);
await b.CalculateBuckets(false, false, false);
var payment = await GetMemberPaymentBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(payment, Has.Count.EqualTo(1));
Assert.That(payment["GV_"], Is.EqualTo(17_000));
});
await b.Calculate();
var prices = await GetMemberDeliveryPrices(year, mgnr);
Assert.Multiple(() => {
Assert.That(prices, Has.Count.EqualTo(6));
// Kabinett
Assert.That(prices[("20201001X001/1", "GV_")], Is.EqualTo((4_000, GV_ungeb)));
// ohne Attribut
Assert.That(prices[("20201001X001/2", "GV_")], Is.EqualTo((4_000, GV_ungeb)));
// Bio
Assert.That(prices[("20201001X002/1", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
// Bio
Assert.That(prices[("20201001X002/2", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
// ohne Attribut
Assert.That(prices[("20201001X003/1", "GV_")], Is.EqualTo(( 500, WEI)));
// ohne Attribut
Assert.That(prices[("20201001X003/2", "GV_")], Is.EqualTo(( 500, GV_ungeb)));
});
}
[Test]
public async Task Test_02_SimpleNotStrictAreaComs() {
int mgnr = MgNr1, year = Year2;
var areaCom = await GetMemberAreaCommitmentBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(areaCom, Has.Count.EqualTo(1));
Assert.That(areaCom["GV"], Is.EqualTo(new AreaComBucket(10_000, 5_000, 10_000)));
});
var delivery = await GetMemberDeliveryBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(delivery, Has.Count.EqualTo(3));
Assert.That(delivery["GV"], Is.EqualTo(16_000));
Assert.That(delivery["GV_"], Is.EqualTo( 1_000));
Assert.That(delivery["GVK"], Is.EqualTo( 4_000));
});
BillingVariant b = new(year, 1);
await b.CalculateBuckets(false, false, false, Connection);
var payment = await GetMemberPaymentBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(payment, Has.Count.EqualTo(2));
Assert.That(payment["GV_"], Is.EqualTo( 7_000));
Assert.That(payment["GV"], Is.EqualTo(10_000));
});
await b.Calculate(false, false, false);
var prices = await GetMemberDeliveryPrices(year, mgnr);
Assert.Multiple(() => {
Assert.That(prices, Has.Count.EqualTo(7));
// Kabinett
Assert.That(prices[("20211001X001/1", "GV")] , Is.EqualTo((4_000, GV_geb)));
// ohne Attribut
Assert.That(prices[("20211001X001/2", "GV")], Is.EqualTo((4_000, GV_geb)));
// Bio
Assert.That(prices[("20211001X002/1", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
// Bio
Assert.That(prices[("20211001X002/2", "GV_")], Is.EqualTo((2_000, GVB_ungeb)));
Assert.That(prices[("20211001X002/2", "GV")], Is.EqualTo((2_000, GVB_geb)));
// ohne Attribut
Assert.That(prices[("20211001X003/1", "GV_")], Is.EqualTo(( 500, WEI)));
// ohne Attribut
Assert.That(prices[("20211001X003/2", "GV_")], Is.EqualTo(( 500, GV_ungeb)));
});
}
[Test]
public async Task Test_03_SimpleNotStrictAreaComs_HonorGebunden() {
int mgnr = MgNr1, year = Year2;
var areaCom = await GetMemberAreaCommitmentBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(areaCom, Has.Count.EqualTo(1));
Assert.That(areaCom["GV"], Is.EqualTo(new AreaComBucket(10_000, 5_000, 10_000)));
});
var delivery = await GetMemberDeliveryBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(delivery, Has.Count.EqualTo(3));
Assert.That(delivery["GV"], Is.EqualTo(16_000));
Assert.That(delivery["GV_"], Is.EqualTo( 1_000));
Assert.That(delivery["GVK"], Is.EqualTo( 4_000));
});
BillingVariant b = new(year, 1);
await b.CalculateBuckets(true, false, false, Connection);
var payment = await GetMemberPaymentBuckets(year, mgnr);
Assert.Multiple(() => {
Assert.That(payment, Has.Count.EqualTo(2));
Assert.That(payment["GV_"], Is.EqualTo(9_000));
Assert.That(payment["GV"], Is.EqualTo(8_000));
});
await b.Calculate(true, false, false);
var prices = await GetMemberDeliveryPrices(year, mgnr);
Assert.Multiple(() => {
Assert.That(prices, Has.Count.EqualTo(6));
// Kabinett
Assert.That(prices[("20211001X001/1", "GV")], Is.EqualTo((4_000, GV_geb)));
// ohne Attribut
Assert.That(prices[("20211001X001/2", "GV_")], Is.EqualTo((4_000, GV_ungeb)));
// Bio
Assert.That(prices[("20211001X002/1", "GV")], Is.EqualTo((4_000, GVB_geb)));
// Bio
Assert.That(prices[("20211001X002/2", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
// ohne Attribut
Assert.That(prices[("20211001X003/1", "GV_")], Is.EqualTo(( 500, WEI)));
// ohne Attribut
Assert.That(prices[("20211001X003/2", "GV_")], Is.EqualTo(( 500, GV_ungeb)));
});
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_04_ComplexNotStrictAreaComs() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_05_ComplexNotStrictAreaComs_HonorGebunden() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_06_StrictAreaComs_NoFillLower_NotAllowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_07_StrictAreaComs_NoFillLower_Allowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_08_StrictAreaComs_NoFillLower_Allowed_AvoidUnderDeliveries() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_09_StrictAreaComs_FillLowerUntilObligation_NotAllowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_10_StrictAreaComs_FillLowerUntilObligation_Allowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_11_StrictAreaComs_FillLowerUntilObligation_Allowed_AvoidUnderDeliveries() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_12_StrictAreaComs_FillLowerUntilObligation_NotAllowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_13_StrictAreaComs_FillLowerUntilObligation_Allowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_14_StrictAreaComs_FillLowerUntilObligation_Allowed_AvoidUnderDeliveries() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_15_StrictAreaComs_FillLowerUntilRight_NotAllowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_16_StrictAreaComs_FillLowerUntilRight_Allowed() {
// TODO
return Task.CompletedTask;
}
[Test]
[Ignore("Not implemented yet")]
public Task Test_17_StrictAreaComs_FillLowerUntilRight_Allowed_AvoidUnderDeliveries() {
// TODO
return Task.CompletedTask;
}
}
}

121
Tests/UnitTests/HelperTests/EbicsTest.cs Normal file
View File

@ -0,0 +1,121 @@
using Elwig.Helpers;
using Elwig.Helpers.Export;
using Elwig.Models.Dtos;
using Elwig.Models.Entities;
using System.Reflection;
using System.Xml;
namespace Tests.UnitTests.HelperTests {
// see https://www.iso20022.org/iso-20022-message-definitions
// and https://www.iso20022.org/catalogue-messages/iso-20022-messages-archive?search=pain
[TestFixture]
public class EbicsTest {
public static readonly string FileName = Path.Combine(Path.GetTempPath(), "test_ebics.xml");
public static readonly string Iban = "AT123456789012345678";
private static void ValidateSchema(string xmlPath, int version, string? extra = null) {
XmlDocument xml = new();
xml.Load(xmlPath);
var schema = new XmlTextReader(Assembly.GetExecutingAssembly()
.GetManifestResourceStream($"Tests.Resources.Schemas.pain.001.001.{version:00}{extra}.xsd")!);
xml.Schemas.Add(null, schema);
xml.Validate(null);
}
private static async Task CreateXmlFile(int version, Ebics.AddressMode mode = Ebics.AddressMode.Full) {
var v = new PaymentVar() {
Year = 2020,
AvNr = 1,
Name = "Endauszahlung",
TransferDate = new DateOnly(2021, 6, 15),
Data = "",
DateString = "2021-01-31",
};
using var ctx = new AppDbContext();
var members = ctx.Members.ToList();
Assert.That(members, Has.Count.GreaterThan(0));
using var exporter = new Ebics(v, FileName, version, mode);
await exporter.ExportAsync(members.Select(m => new Transaction(m, 1234.56m, "EUR", m.MgNr % 100)));
}
[TearDown]
public static void RemoveXmlFile() {
File.Delete(FileName);
}
[Test]
[Ignore("Version has no need to be supported")]
public async Task Test_CustomerCreditTransferInitiationV01() {
await CreateXmlFile(1);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 1));
}
[Test]
[Ignore("Version has no need to be supported")]
public async Task Test_CustomerCreditTransferInitiationV02() {
await CreateXmlFile(2);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 2));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV03() {
await CreateXmlFile(3);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 3));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV03_AT() {
await CreateXmlFile(3, Ebics.AddressMode.Lines);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 3, ".AT"));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV04() {
await CreateXmlFile(4);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 4));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV05() {
await CreateXmlFile(5);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 5));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV06() {
await CreateXmlFile(6);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 6));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV07() {
await CreateXmlFile(7);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 7));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV08() {
await CreateXmlFile(8);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 8));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV09() {
await CreateXmlFile(9);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 9));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV10() {
await CreateXmlFile(10);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 10));
}
[Test]
public async Task Test_CustomerCreditTransferInitiationV11() {
await CreateXmlFile(11);
Assert.DoesNotThrow(() => ValidateSchema(FileName, 11));
}
}
}

151
Tests/UnitTests/HelperTests/UtilsTest.cs Normal file
View File

@ -0,0 +1,151 @@
using Elwig.Helpers;
namespace Tests.UnitTests.HelperTests {
[TestFixture]
public class UtilsTest {
private static readonly double[,] Gradation = new double[,] {
{ 14.0, 68.0 },
{ 15.0, 73.0 },
{ 17.1, 84.0 },
{ 19.0, 94.0 },
{ 21.0, 105.0 },
{ 25.0, 127.0 },
{ 27.1, 139.0 },
{ 30.0, 156.0 },
};
[Test]
public void Test_KmwToOe() {
Assert.Multiple(() => {
for (int i = 0; i < Gradation.GetLength(0); i++) {
Assert.That(Utils.KmwToOe(Gradation[i, 0]), Is.EqualTo(Gradation[i, 1]));
}
});
}
[Test]
public void Test_OeToKmw() {
Assert.Multiple(() => {
for (int i = 0; i < Gradation.GetLength(0); i++) {
Assert.That(Utils.OeToKmw(Gradation[i, 1]), Is.EqualTo(Gradation[i, 0]));
}
});
}
[Test]
public void Test_DecFromDb() {
Assert.Multiple(() => {
Assert.That(Utils.DecFromDb(10670, 3), Is.EqualTo(10.67M));
Assert.That(Utils.DecFromDb(-1009999, 4), Is.EqualTo(-100.9999M));
Assert.That(Utils.DecFromDb(1, 2), Is.EqualTo(0.01M));
});
}
[Test]
public void Test_DecToDb() {
Assert.Multiple(() => {
Assert.That(Utils.DecToDb(219.48M, 2), Is.EqualTo(21948));
Assert.That(Utils.DecToDb(-1.2345M, 4), Is.EqualTo(-12345));
Assert.That(Utils.DecToDb(99190, 0), Is.EqualTo(99190));
Assert.That(Utils.DecToDb(817.9099M, 3), Is.EqualTo(817910));
Assert.That(Utils.DecToDb(-5618.944M, 2), Is.EqualTo(-561894));
});
}
[Test]
public void Test_Modulo() {
Assert.Multiple(() => {
Assert.That(Utils.Modulo("1", 2), Is.EqualTo(1));
Assert.That(Utils.Modulo("12", 11), Is.EqualTo(1));
Assert.That(Utils.Modulo("65", 16), Is.EqualTo(1));
Assert.That(Utils.Modulo("91746381048364", 10), Is.EqualTo(4));
Assert.That(Utils.Modulo("210501700012345678131468", 97), Is.EqualTo(1));
Assert.Throws<ArgumentException>(() => Utils.Modulo("", 4));
Assert.Throws<ArgumentException>(() => Utils.Modulo("1ab", 5));
Assert.Throws<ArgumentException>(() => Utils.Modulo("123", 1));
Assert.Throws<ArgumentException>(() => Utils.Modulo("456", 0));
Assert.Throws<ArgumentException>(() => Utils.Modulo("789", -1));
});
}
[Test]
public void Test_SplitAddress() {
Assert.Multiple(() => {
Assert.That(Utils.SplitAddress("Winzerstraße 1"), Is.EqualTo(("Winzerstraße", "1")));
Assert.That(Utils.SplitAddress("Auf dem Feld 12"), Is.EqualTo(("Auf dem Feld", "12")));
Assert.That(Utils.SplitAddress("Winzerstraße 5a"), Is.EqualTo(("Winzerstraße", "5a")));
Assert.That(Utils.SplitAddress("Winzerstraße 1-3/2"), Is.EqualTo(("Winzerstraße", "1-3/2")));
Assert.That(Utils.SplitAddress("Winzerstraße 3/4/5"), Is.EqualTo(("Winzerstraße", "3/4/5")));
Assert.That(Utils.SplitAddress("Winzerstraße 7/2/4/77"), Is.EqualTo(("Winzerstraße", "7/2/4/77")));
Assert.That(Utils.SplitAddress("Winzerstraße 95b"), Is.EqualTo(("Winzerstraße", "95b")));
Assert.That(Utils.SplitAddress("Winzerstraße 1, TOP 3"), Is.EqualTo(("Winzerstraße", "1, TOP 3")));
});
}
[Test]
public void Test_SplitName() {
Assert.Multiple(() => {
Assert.That(Utils.SplitName("Max Bauer", "Bauer"), Is.EqualTo(("Bauer", "Max")));
Assert.That(Utils.SplitName("Bauer Max", "Bauer"), Is.EqualTo(("Bauer", "Max")));
Assert.That(Utils.SplitName("Max und Moritz Bauer", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz")));
Assert.That(Utils.SplitName("Bauer Max und Moritz", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz")));
Assert.That(Utils.SplitName("Bauer GesbR", "Bauer"), Is.EqualTo(("Bauer", "GesbR")));
Assert.That(Utils.SplitName("Max und Moritz Bauer GesbR", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz GesbR")));
Assert.That(Utils.SplitName("Bauer Max und Moritz GesbR", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz GesbR")));
Assert.That(Utils.SplitName("Weingut Bauer", "Bauer"), Is.EqualTo(("Bauer", "Weingut")));
Assert.That(Utils.SplitName("Bauer Weingut", "Bauer"), Is.EqualTo(("Bauer", "Weingut")));
Assert.That(Utils.SplitName("Max und Moritz Bauer und Mustermann", "Bauer"), Is.EqualTo(("Bauer und Mustermann", "Max und Moritz")));
Assert.That(Utils.SplitName("Bauer und Mustermann Max und Moritz", "Bauer"), Is.EqualTo(("Bauer und Mustermann", "Max und Moritz")));
Assert.That(Utils.SplitName("ABC GesbR", "Bauer"), Is.EqualTo(((string, string?))("ABC GesbR", null)));
});
}
[Test]
public void Test_CalcCrc16Modbus() {
Assert.Multiple(() => {
Assert.That(Utils.CalcCrc16Modbus(""), Is.EqualTo(0xFFFF));
Assert.That(Utils.CalcCrc16Modbus("abcd"), Is.EqualTo(0x1D97));
Assert.That(Utils.CalcCrc16Modbus("ABCD"), Is.EqualTo(0x0F85));
// Matzen (SysTec IT3000A)
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:03 01 0 0 0kg 1"), Is.EqualTo(43166));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:04 01 0 0 0kg 1"), Is.EqualTo(21615));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:05 01 0 0 0kg 1"), Is.EqualTo(40446));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:06 01 0 0 0kg 1"), Is.EqualTo(34638));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:07 01 0 0 0kg 1"), Is.EqualTo(20191));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:08 01 0 0 0kg 1"), Is.EqualTo(16047));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:09 01 0 0 0kg 1"), Is.EqualTo(63294));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:10 01 0 0 0kg 1"), Is.EqualTo(7718));
Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:12 01 0 0 0kg 1"), Is.EqualTo(52487));
// Wolkersdorf, Waage 1 (SysTec IT6000E)
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50 51 0 0 0kg A"), Is.EqualTo(10187));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50 61 0 0 0kg A"), Is.EqualTo(20683));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50 71 0 0 0kg A"), Is.EqualTo(48586));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50 81 0 0 0kg A"), Is.EqualTo(22217));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50 91 0 0 0kg A"), Is.EqualTo(48072));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 101 0 0 0kg A"), Is.EqualTo(30119));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 111 0 0 0kg A"), Is.EqualTo(39078));
// Wolkersdorf, Waage 2 (SysTec IT6000E)
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 41 0 0 0kg B"), Is.EqualTo(539));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 51 0 0 0kg B"), Is.EqualTo(61210));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 61 0 0 0kg B"), Is.EqualTo(38938));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 71 0 0 0kg B"), Is.EqualTo(29979));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 81 0 0 0kg B"), Is.EqualTo(40472));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 91 0 0 0kg B"), Is.EqualTo(29465));
Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51 101 0 0 0kg B"), Is.EqualTo(29927));
// Gr.Inzersdorf (L246/IT3)
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49 11 0 0 0kg 001"), Is.EqualTo(27556));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49 21 0 0 0kg 001"), Is.EqualTo(7332));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49 31 0 0 0kg 001"), Is.EqualTo(61861));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49 41 0 0 0kg 001"), Is.EqualTo(62116));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49 51 0 0 0kg 001"), Is.EqualTo(8101));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49 61 0 0 0kg 001"), Is.EqualTo(26789));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49 71 50 0 50kg 001"), Is.EqualTo(16188));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50 81 35 0 35kg 001"), Is.EqualTo(12015));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50 91 40 0 40kg 001"), Is.EqualTo(60047));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50 101 40 0 40kg 001"), Is.EqualTo(60785));
Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50 111 45 0 45kg 001"), Is.EqualTo(35918));
});
}
}
}

113
Tests/UnitTests/HelperTests/ValidatorTest.cs Normal file
View File

@ -0,0 +1,113 @@
using Elwig.Helpers;
using System.Windows.Controls;
namespace Tests.UnitTests.HelperTests {
[TestFixture]
[Apartment(ApartmentState.STA)]
public class ValidatorTest {
private static TextBox TB(string value, int caret = 0) {
return new() {
Text = value,
CaretIndex = caret,
};
}
[Test]
public void Test_CheckInteger_Simple() {
Assert.Multiple(() => {
Assert.That(Validator.CheckInteger(TB(""), true).IsValid, Is.False);
Assert.That(Validator.CheckInteger(TB(""), false).IsValid, Is.True);
Assert.That(Validator.CheckInteger(TB("123"), true).IsValid, Is.True);
Assert.That(Validator.CheckInteger(TB("456"), false).IsValid, Is.True);
Assert.That(Validator.CheckInteger(TB("1234"), false, 4).IsValid, Is.True);
Assert.That(Validator.CheckInteger(TB("4567"), false, 3).IsValid, Is.True);
});
}
[Test]
public void Test_CheckInteger_Caret() {
var tb = TB("1a2b3c", 2);
Assert.Multiple(() => {
Assert.That(Validator.CheckInteger(tb, true).IsValid, Is.True);
Assert.That(tb.Text, Is.EqualTo("123"));
Assert.That(tb.CaretIndex, Is.EqualTo(1));
});
}
[Test]
public void Test_CheckInteger_MaxLen() {
var tb = TB("1a2b3c4d5e", 4);
Assert.Multiple(() => {
Assert.That(Validator.CheckInteger(tb, true, 3).IsValid, Is.True);
Assert.That(tb.Text, Is.EqualTo("123"));
Assert.That(tb.CaretIndex, Is.EqualTo(2));
});
}
[Test]
public void Test_CheckPhoneNumber_Simple() {
Assert.Multiple(() => {
Assert.That(Validator.CheckPhoneNumber(TB(""), true).IsValid, Is.False);
Assert.That(Validator.CheckPhoneNumber(TB("+43"), false).IsValid, Is.False);
Assert.That(Validator.CheckPhoneNumber(TB("066412345678"), true).IsValid, Is.True);
Assert.That(Validator.CheckPhoneNumber(TB("0ab66412cd345678"), true).IsValid, Is.True);
});
}
[Test]
public void Test_CheckPhoneNumber_Format_1() {
var tb = TB("066412345678", 5);
Assert.Multiple(() => {
Assert.That(Validator.CheckPhoneNumber(tb, true).IsValid, Is.True);
Assert.That(tb.Text, Is.EqualTo("+43 664 12345678"));
Assert.That(tb.CaretIndex, Is.EqualTo(9));
});
}
[Test]
public void Test_CheckPhoneNumber_Format_2() {
var tb = TB("0a2574b1c2d34..", 7);
Assert.Multiple(() => {
Assert.That(Validator.CheckPhoneNumber(tb, true).IsValid, Is.True);
Assert.That(tb.Text, Is.EqualTo("+43 2574 1234"));
Assert.That(tb.CaretIndex, Is.EqualTo(8));
});
}
[Test]
public void Test_CheckEmailAddress_Simple() {
Assert.Multiple(() => {
Assert.That(Validator.CheckEmailAddress(TB(""), true).IsValid, Is.False);
Assert.That(Validator.CheckEmailAddress(TB("name"), false).IsValid, Is.False);
Assert.That(Validator.CheckEmailAddress(TB("@"), false).IsValid, Is.False);
Assert.That(Validator.CheckEmailAddress(TB("@test.com"), false).IsValid, Is.False);
Assert.That(Validator.CheckEmailAddress(TB("name@a"), true).IsValid, Is.False);
Assert.That(Validator.CheckEmailAddress(TB("name@a.com."), true).IsValid, Is.False);
Assert.That(Validator.CheckEmailAddress(TB("name@a.com.a"), true).IsValid, Is.False);
Assert.That(Validator.CheckEmailAddress(TB("name@a.com"), true).IsValid, Is.True);
Assert.That(Validator.CheckEmailAddress(TB("my.name@hello#.com"), true).IsValid, Is.True);
});
}
[Test]
public void Test_CheckEmailAddress_Format_1() {
var tb = TB("my . name . is @heinz#.com", 17);
Assert.Multiple(() => {
Assert.That(Validator.CheckEmailAddress(tb, true).IsValid, Is.True);
Assert.That(tb.Text, Is.EqualTo("my.name.is@heinz.com"));
Assert.That(tb.CaretIndex, Is.EqualTo(12));
});
}
[Test]
public void Test_CheckEmailAddress_Format_2() {
var tb = TB("sabine.müsterfrau@heinz#.com.b", 30);
Assert.Multiple(() => {
Assert.That(Validator.CheckEmailAddress(tb, true).IsValid, Is.False);
Assert.That(tb.Text, Is.EqualTo("sabine.müsterfrau@heinz.com.b"));
Assert.That(tb.CaretIndex, Is.EqualTo(29));
});
}
}
}