public async Task Check_Logging_When_Reading()
{
// Arrange
var logger = Mock.Of <ILogger>();
LogManager.LoggerFactory = () => logger;
LogManager.LogAllReadAndWriteOperations = true;
var byteItem = new BytePlcItem(dataBlock: 0, position: 0, initialValue: Byte.MaxValue);
ICollection <IPlcItem> items = new IPlcItem[] { byteItem, byteItem.Clone(), byteItem.Clone() };
var plcMock = new Mock <Plc>(Guid.NewGuid().ToString());
plcMock
.Setup(p => p.ReadItemsAsync(It.IsAny <IList <IPlcItem> >(), CancellationToken.None))
#if NET45
.Returns(CompletedTask)
#else
.Returns(Task.CompletedTask)
#endif
;
var plc = plcMock.Object;
// Act
await plc.ReadItemsAsync(items);
// Assert
Mock.Get(logger).Verify(l => l.Trace(It.IsAny <string>(), It.IsAny <object[]>()), Times.Exactly(items.Count));
}
public void Check_Clone()
{
var item = new BytePlcItem(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 async Task MonitorDifferentIntervals()
{
var monitoredChangesOfFirstItem = 0;
var monitoredChangesOfSecondItem = 0;
var firstMonitorItemIdentifier = "Monitored item #01";
uint firstMonitorItemInterval = 50;
var secondMonitorItemIdentifier = "Monitored item #02";
uint secondMonitorItemInterval = 200;
var changes = 100;
var secondChanges = changes / ((secondMonitorItemInterval / firstMonitorItemInterval) / 2);
var monitoredPlc = new MockPlc().MakeMonitorable
(
new Dictionary <string, uint>
{
{ firstMonitorItemIdentifier, firstMonitorItemInterval }
, { secondMonitorItemIdentifier, secondMonitorItemInterval }
}
);
// Create items that must be monitored.
var firstMonitoredItem = new BytePlcItem(dataBlock: Data.Datablock, position: Data.StartOfModifiableBytes, identifier: firstMonitorItemIdentifier);
var secondMonitoredItem = firstMonitoredItem.Clone(secondMonitorItemIdentifier);
// Create the item that is used to manipulate the value.
IPlcItem writeItem = firstMonitoredItem.Clone("ChangeItem");
// Set a callback for changes to the items.
firstMonitoredItem.ValueChanged += (sender, args) =>
{
monitoredChangesOfFirstItem++;
};
secondMonitoredItem.ValueChanged += (sender, args) =>
{
monitoredChangesOfSecondItem++;
};
try
{
// Connect to the plc.
monitoredPlc.Connect();
// Start monitoring those items.
monitoredPlc.MonitorItem(firstMonitoredItem);
monitoredPlc.MonitorItem(secondMonitoredItem);
monitoredPlc.Start();
// Manipulate the monitored value.
for (byte i = 1; i <= changes; i++)
{
writeItem.Value.TransferValuesFrom(new[] { i });
await monitoredPlc.WriteItemAsync(writeItem);
await Task.Delay((int)firstMonitorItemInterval * 2); // This must be at least the double amount of the polling interval.
}
// Stop monitoring.
monitoredPlc.Stop();
// Check if all changes where registered.
Assert.AreEqual(changes, monitoredChangesOfFirstItem);
Assert.True(monitoredChangesOfSecondItem >= secondChanges);
}
finally
{
monitoredPlc.Dispose();
}
}
public async Task MonitorChanges()
{
var changes = 100;
var target = (changes * (changes + 1)) / 2; // Gaußsche Summenformel
var monitoredChanges = 0;
var collectedValue = 0;
var monitorItemIdentifier = "MonitoredItem";
uint monitorItemInterval = 50;
var monitoredPlc = new MockPlc().MakeMonitorable
(
new Dictionary <string, uint>
{
{ monitorItemIdentifier, monitorItemInterval }
}
);
// Create the item that must be monitored.
var monitorItem = new BytePlcItem(dataBlock: Data.Datablock, position: Data.StartOfModifiableBytes, identifier: monitorItemIdentifier);
// Create the item that is used to manipulate the value.
IPlcItem writeItem = monitorItem.Clone("ChangeItem");
// Set a callback for changes to the items.
monitorItem.ValueChanged += (sender, args) =>
{
monitoredChanges++;
collectedValue += args.NewValue;
};
try
{
// Connect to the plc.
monitoredPlc.Connect();
// Start monitoring those items.
monitoredPlc.MonitorItem(monitorItem);
monitoredPlc.Start();
// Manipulate the monitored value.
for (byte i = 1; i <= changes; i++)
{
writeItem.Value.TransferValuesFrom(new[] { i });
await monitoredPlc.WriteItemAsync(writeItem);
await Task.Delay((int)monitorItemInterval * 2); // This must be at least the double amount of the polling interval.
}
// Stop monitoring.
monitoredPlc.Stop();
// Further manipulate the value to check if this is not monitored.
writeItem.Value.TransferValuesFrom(new[] { byte.MinValue });
writeItem.Value.TransferValuesFrom(new[] { byte.MaxValue });
// Check if all changes where registered.
Assert.AreEqual(changes, monitoredChanges);
Assert.AreEqual(target, collectedValue);
Assert.AreEqual(changes, monitorItem.Value);
}
finally
{
monitoredPlc.Dispose();
}
}
