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(); } }