public void Check_Set_Value_From_String(string value, bool targetResult)
{
// Arrange
var item = new BytesPlcItem(0, 0, true, new byte[0]);
// Act
var result = item.SetValue(value);
// Assert
Assert.That(result, Is.EqualTo(targetResult));
}
public void CheckTypedValueEquality()
{
// Arrange
var data = Enumerable.Range(byte.MinValue, byte.MaxValue).Select(value => (byte)value).ToArray();
var plcItem = new BytesPlcItem(dataBlock: 1234, position: 10, initialValue: data);
var typedValue = plcItem.Value;
// Act
var underlyingValue = (byte[])((IPlcItem)plcItem).Value;
// Assert
Assert.True(typedValue.SequenceEqual(underlyingValue));
}
public void Check_Initial_Data()
{
// Arrange
var targetValue = TargetValue;
var targetData = TargetValue;
// Act
var item = new BytesPlcItem(0, 0, targetValue);
// Assert: Number → Data
Assert.That(item.Value, Is.EqualTo(targetValue));
Assert.That((byte[])((IPlcItem)item).Value, Is.EqualTo(targetData));
}
public void CheckClone()
{
// Arrange
var data = Enumerable.Range(byte.MinValue, byte.MaxValue).Select(value => (byte)value).ToArray();
IPlcItem plcItem = new BytesPlcItem(dataBlock: 1234, position: 10, initialValue: data); //! Explicitly cast this to 'IPlcItem' so that its 'Value' is a 'BitCollection'.
// Act
IPlcItem clonedPlcItem = plcItem.Clone();
// Assert
Assert.True(plcItem.Equals(clonedPlcItem));
Assert.False(Object.ReferenceEquals(plcItem, clonedPlcItem));
Assert.True(plcItem.Value.Equals(clonedPlcItem.Value));
}
public void Check_FromData()
{
// Arrange
var targetValue = TargetValue;
var targetData = TargetValue;
var item = new BytesPlcItem(0, 0, (ushort)targetData.Length);
// Act: Data → Number
((IPlcItem)item).Value.TransferValuesFrom(targetData);
// Assert
Assert.That(item.Value, Is.EqualTo(targetValue));
Assert.That((byte[])((IPlcItem)item).Value, Is.EqualTo(targetData));
}
public void Check_ToData()
{
// Arrange
var targetValue = TargetValue;
var targetData = TargetValue;
var item = new BytesPlcItem(0, 0, (ushort)targetData.Length);
// Act: Number → Data
item.Value = targetValue;
// Assert
Assert.That(item.Value, Is.EqualTo(targetValue));
Assert.That((byte[])((IPlcItem)item).Value, Is.EqualTo(targetData));
}
public void Check_Clone()
{
var item = new BytesPlcItem(0, 0, TargetValue);
var clone = item.Clone();
// Check equality (Equals is overriden).
Assert.AreEqual(item, clone);
// Check the value.
Assert.AreEqual(item.Value, clone.Value);
// Check if both items are different references.
Assert.False(Object.ReferenceEquals(item, clone));
}
public void ReadBytes()
{
var bytesItem = new BytesPlcItem(dataBlock: this.Data.Datablock, position: 0, byteAmount: (ushort)this.Data.TargetBytes.Length);
base.ExecuteTest
(
async(plc) =>
{
var result = await plc.ReadItemAsync(bytesItem);
Assert.True(bytesItem.Value == result); //! Because of the conversion, this is sequentially equal, but not referential.
Assert.True(result.SequenceEqual(this.Data.TargetBytes));
}
);
}
public void WriteBytes()
{
var writeItem = new BytesPlcItem(dataBlock: this.Data.Datablock, position: 4, initialValue: this.Data.WriteBytes);
//var writeItem = new BytesPlcItem(dataBlock: Data.Datablock, position: 0, initialValue: Data.TargetBytes);
base.ExecuteTest
(
async(plc) =>
{
var result = await plc.WriteItemWithValidationAsync(writeItem);
Assert.True(result);
}
);
}
public async Task MonitorDifferentIdenticalItems()
{
var firstMonitoredItem = new BytesPlcItem(dataBlock: Data.Datablock, position: Data.StartOfFixedBytes, byteAmount: 2);
var secondMonitoredItem = new UInt16PlcItem(dataBlock: Data.Datablock, position: Data.StartOfFixedBytes);
var thirdMonitoredItem = new BitsPlcItem(dataBlock: Data.Datablock, position: Data.StartOfFixedBytes, bitPosition: BitPosition.X0, bitAmount: 16);
var differentReadItems = new HashSet <IPlcItem>(new ReferenceComparer());
var mockPlc = new MockPlc();
Func <ICollection <IPlcItem>, CancellationToken, Task> performReadItemsAsyncMock = (plcItems, cancellationToken) =>
{
foreach (var plcItem in plcItems)
{
differentReadItems.Add(plcItem);
}
return(mockPlc.ReadItemsAsync(plcItems, cancellationToken));
};
// Create a mock of MockPlc that signals which items are read.
var plcMock = new Mock <IPlc>(behavior: MockBehavior.Strict)
{
CallBase = true,
};
plcMock
.Setup(x => x.ReadItemsAsync(It.IsAny <IPlcItem[]>(), It.IsAny <CancellationToken>()))
.Returns(performReadItemsAsyncMock)
.Verifiable()
;
// Create the monitor with the mocked instance.
var monitoredPlc = new PollingMonitorablePlc(plcMock.Object);
// Start monitoring those items.
monitoredPlc.MonitorItem(firstMonitoredItem);
monitoredPlc.MonitorItem(secondMonitoredItem);
monitoredPlc.MonitorItem(thirdMonitoredItem);
monitoredPlc.Start();
await Task.Delay(1000);
monitoredPlc.Stop();
Assert.AreEqual(1, differentReadItems.Count);
}
public virtual void ReadUndefinedDatablock()
{
// Arrange
var validItem = new BytesPlcItem(dataBlock: this.Data.Datablock, position: 0, byteAmount: (ushort)this.Data.TargetBytes.Length);
var invalidItem = new BytesPlcItem(dataBlock: ushort.MaxValue, position: 1, byteAmount: 100); //! Hopefully that datablock doesn't exists in the test system...
base.ExecuteTest
(
(plc) =>
{
// Act + Assert
var ex = Assert.ThrowsAsync <ReadPlcException>(() => plc.ReadItemsAsync(new[] { validItem, invalidItem }));
Assert.That(ex.ValidItems.FirstOrDefault(), Is.EqualTo(validItem));
Assert.That(ex.FailedItems.FirstOrDefault().FailedItem, Is.EqualTo(invalidItem));
#if NET45
return(CompletedTask);
#else
return(System.Threading.Tasks.Task.CompletedTask);
#endif
}
);
}
public void CheckItemBuilder()
{
var itemBuilder = new PlcItemBuilder();
var plcItem = itemBuilder
.Construct("Generic")
.ForData()
.AtDatablock(0)
.AtPosition(0, BitPosition.X2)
.ForBitAmount(3)
.Build()
;
Assert.AreEqual((uint)3, plcItem.Value.Length);
BitsPlcItem bitsItem = itemBuilder
.ConstructBitsPlcItem()
.ForFlags()
.AtPosition(20, BitPosition.X5)
.ForBitAmount(5)
.Build()
;
Assert.AreEqual((uint)5, ((IPlcItem)bitsItem).Value.Length);
BitPlcItem bitItem = itemBuilder
.ConstructBitPlcItem("Bit")
.ForData()
.AtDatablock(0)
.AtPosition(5)
.AsSet()
.Build()
;
Assert.AreEqual((uint)1, ((IPlcItem)bitItem).Value.Length);
BytesPlcItem bytesItem = itemBuilder
.ConstructBytesPlcItem(identifier: "Bytes")
.ForOutput()
.AtPosition(0)
.WithInitialValue(new[] { byte.MinValue, byte.MaxValue })
.Build()
;
Assert.AreEqual((uint)2, ((IPlcItem)bytesItem).Value.ByteLength);
BytePlcItem byteItem = itemBuilder
.ConstructBytePlcItem("Byte")
.ForInput()
.AtPosition(10)
.WithInitialValue(Byte.MaxValue)
.Build()
;
Assert.AreEqual((uint)sizeof(Byte), ((IPlcItem)byteItem).Value.ByteLength);
Int16PlcItem int16Item = itemBuilder
.ConstructInt16PlcItem("Int16")
.AtDatablock(0)
.AtPosition(1)
.WithoutInitialValue()
.Build()
;
Assert.AreEqual((uint)sizeof(Int16), ((IPlcItem)int16Item).Value.ByteLength);
Int32PlcItem int32Item = itemBuilder
.ConstructInt32PlcItem("Int32")
.AtDatablock(0)
.AtPosition(1)
.WithInitialValue(int.MinValue)
.Build()
;
Assert.AreEqual((uint)sizeof(Int32), ((IPlcItem)int32Item).Value.ByteLength);
Int64PlcItem int64Item = itemBuilder
.ConstructInt64PlcItem("Int64")
.AtDatablock(0)
.AtPosition(1)
.WithInitialValue(long.MinValue)
.Build()
;
Assert.AreEqual((uint)sizeof(Int64), ((IPlcItem)int64Item).Value.ByteLength);
UInt16PlcItem uInt16Item = itemBuilder
.ConstructUInt16PlcItem("UInt16")
.AtDatablock(0)
.AtPosition(1)
.WithoutInitialValue()
.Build()
;
Assert.AreEqual((uint)sizeof(UInt16), ((IPlcItem)uInt16Item).Value.ByteLength);
UInt32PlcItem uInt32PlcItem = itemBuilder
.ConstructUInt32PlcItem("UInt32")
.AtDatablock(0)
.AtPosition(1)
.WithInitialValue(uint.MaxValue)
.Build()
;
Assert.AreEqual((uint)sizeof(UInt32), ((IPlcItem)uInt32PlcItem).Value.ByteLength);
UInt64PlcItem uInt64PlcItem = itemBuilder
.ConstructUInt64PlcItem("UInt64")
.AtDatablock(0)
.AtPosition(1)
.WithInitialValue(ulong.MaxValue)
.Build()
;
Assert.AreEqual((uint)sizeof(UInt64), ((IPlcItem)uInt64PlcItem).Value.ByteLength);
WordPlcItem wordItem = itemBuilder
.ConstructWordPlcItem("Word")
.AtDatablock(0)
.AtPosition(2)
.WithInitialValue(32458)
.Build()
;
Assert.AreEqual((uint)2, ((IPlcItem)wordItem).Value.ByteLength);
DWordPlcItem dwordItem = itemBuilder
.ConstructDWordPlcItem("DWord")
.AtDatablock(0)
.AtPosition(2)
.WithInitialValue(uint.MaxValue)
.Build()
;
Assert.AreEqual((uint)4, ((IPlcItem)dwordItem).Value.ByteLength);
LWordPlcItem lwordItem = itemBuilder
.ConstructLWordPlcItem("LWord")
.AtDatablock(0)
.AtPosition(2)
.WithInitialValue(ulong.MaxValue)
.Build()
;
Assert.AreEqual((uint)8, ((IPlcItem)lwordItem).Value.ByteLength);
TextPlcItem textItem = itemBuilder
.ConstructTextPlcItem("Text")
.WithEncoding(Encoding.UTF7)
.AtDatablock(0)
.AtPosition(3)
.WithInitialValue("Some String")
.Build()
;
Assert.AreEqual((uint)Encoding.UTF7.GetBytes("Some String").Length, ((IPlcItem)textItem).Value.ByteLength);
Utf8PlcItem utf8Item = itemBuilder
.ConstructUtf8PlcItem("UTF-8")
.AtDatablock(0)
.AtPosition(4)
.WithLength(10)
.Build()
;
Assert.AreEqual((uint)10, ((IPlcItem)utf8Item).Value.ByteLength);
var initialText = "String whose length fits into a single byte.";
DynamicUtf8PlcItem secondDynamicUtf8Item = itemBuilder
.ConstructUtf8PlcItem("UTF-8")
.AtDatablock(0)
.AtPosition(4)
.WithDynamicItemFromInitialValue(initialText)
.BuildDynamic()
;
Assert.That(secondDynamicUtf8Item.LengthPlcItem.Value, Is.EqualTo((uint)Encoding.UTF8.GetBytes(initialText).Length));
Assert.AreEqual(initialText, secondDynamicUtf8Item.Value);
var items = new []
{
plcItem,
bitsItem,
bitItem,
bytesItem,
byteItem,
int16Item,
int32Item,
int64Item,
uInt16Item,
uInt32PlcItem,
uInt64PlcItem,
wordItem,
dwordItem,
lwordItem,
textItem,
utf8Item,
secondDynamicUtf8Item,
};
foreach (var item in items)
{
Debug.WriteLine($" -> {item}");
}
}
