public void Check_ItemBuilder()
        {
            // With predefined length-item.
            DynamicUtf8PlcItem item = new Items.Builder.PlcItemBuilder()
                                      .ConstructUtf8PlcItem("UTF8")
                                      .AtDatablock(0)
                                      .AtPosition(0)
                                      .WithDynamicItem <UInt32PlcItem>()
                                      .BuildDynamic()
            ;

            System.Diagnostics.Debug.WriteLine(item.ToString());
            Assert.True(item.LengthPlcItem is UInt32PlcItem);
            Assert.AreEqual(default(UInt32), ((UInt32PlcItem)item.LengthPlcItem).Value);
            Assert.IsNotNull(item.Value);
            Assert.AreEqual(String.Empty, item.Value);

            // With initial value.
            var initialValue = Guid.NewGuid().ToString();

            item = new Items.Builder.PlcItemBuilder()
                   .ConstructUtf8PlcItem("UTF8")
                   .AtDatablock(0)
                   .AtPosition(0)
                   .WithDynamicItemFromInitialValue(initialValue)
                   .BuildDynamic()
            ;
            System.Diagnostics.Debug.WriteLine(item.ToString());
            Assert.True(item.LengthPlcItem is BytePlcItem);
            Assert.AreEqual(Encoding.UTF8.GetBytes(initialValue).Length, ((BytePlcItem)item.LengthPlcItem).Value);
            Assert.AreEqual(initialValue, item.Value);
        }
        public void Check_ItemBuilder()
        {
            // With predefined length-item.
            DynamicBytesPlcItem item = new Items.Builder.PlcItemBuilder()
                                       .ConstructBytesPlcItem("Bytes")
                                       .ForData()
                                       .AtDatablock(0)
                                       .AtPosition(0)
                                       .WithDynamicItem <UInt32PlcItem>()
                                       .BuildDynamic()
            ;

            System.Diagnostics.Debug.WriteLine(item.ToString());
            Assert.True(item.LengthPlcItem is UInt32PlcItem);
            Assert.AreEqual(default(UInt32), ((UInt32PlcItem)item.LengthPlcItem).Value);
            Assert.IsNotNull(item.Value);
            Assert.True(new byte[0].SequenceEqual(item.Value));

            // With initial value.
            var initialValue = new byte[] { Byte.MinValue, Byte.MaxValue, 10, 20, 30, 40, 50 };

            item = new Items.Builder.PlcItemBuilder()
                   .ConstructBytesPlcItem("Bytes")
                   .ForData()
                   .AtDatablock(0)
                   .AtPosition(0)
                   .WithDynamicItemFromInitialValue(initialValue)
                   .BuildDynamic()
            ;
            System.Diagnostics.Debug.WriteLine(item.ToString());
            Assert.True(item.LengthPlcItem is BytePlcItem);
            Assert.AreEqual(initialValue.Length, ((BytePlcItem)item.LengthPlcItem).Value);
            Assert.True(initialValue.SequenceEqual(item.Value));
        }
Exemplo n.º 3
0
        public void Check_ItemBuilder()
        {
            EnumPlcItem <TestEnumeration> item = new Items.Builder.PlcItemBuilder()
                                                 .ConstructEnumPlcItem <TestEnumeration>("Enumeration")
                                                 .AtDatablock(0)
                                                 .AtPosition(0)
                                                 .WithInitialValue(TestEnumeration.Value1)
                                                 .Build()
            ;

            Assert.AreEqual((uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(TestEnumeration).GetEnumUnderlyingType()), ((IPlcItem)item).Value.ByteLength);

            System.Diagnostics.Debug.WriteLine(item.ToString());
        }
Exemplo n.º 4
0
        public void ReadDynamicText()
        {
            var itemBuilder = new Items.Builder.PlcItemBuilder();

            var target     = "ABC";
            var targetData = Encoding.UTF8.GetBytes(target);

            var bytesItem = itemBuilder
                            .ConstructBytesPlcItem()
                            .ForData()
                            .AtDatablock(Data.Datablock)
                            .AtPosition(Data.StartOfModifiableBytes)
                            .WithInitialValue(new[] { (byte)targetData.Length }.Concat(targetData).ToArray())
                            .Build()
            ;

            var dynamicTextItem = itemBuilder
                                  .ConstructUtf8PlcItem()
                                  .AtDatablock(Data.Datablock)
                                  .AtPosition(Data.StartOfModifiableBytes)
                                  .WithDynamicItem <BytePlcItem>()
                                  .BuildDynamic()
            ;

            base.ExecuteTest
            (
                async(plc) =>
            {
                var success = await plc.WriteItemAsync(bytesItem);
                Assert.True(success);

                // Read the dynamic item.
                var result = await plc.ReadItemAsync(dynamicTextItem);

                //Check value and length.
                Assert.AreEqual(target, result);
                Assert.AreEqual(target, dynamicTextItem.Value);
                Assert.AreEqual(result.Length, ((BytePlcItem)dynamicTextItem.LengthPlcItem).Value);
            }
            );
        }
        public void WriteDynamic()
        {
            var itemBuilder = new Items.Builder.PlcItemBuilder();

            var target = "ABC";
            //var targetData = Encoding.UTF8.GetBytes(target);

            var bytesItem = itemBuilder
                            .ConstructBytesPlcItem()
                            .ForData()
                            .AtDatablock(Data.Datablock)
                            .AtPosition(Data.StartOfModifiableBytes)
                            .ForByteAmount((uint)Data.WriteBytes.Length)
                            .Build()
            ;

            var dynamicTextItem = itemBuilder
                                  .ConstructUtf8PlcItem()
                                  .AtDatablock(Data.Datablock)
                                  .AtPosition(Data.StartOfModifiableBytes)
                                  .WithDynamicItemFromInitialValue(target)
                                  .BuildDynamic()
            ;

            base.ExecuteTest
            (
                async(plc) =>
            {
                // Clear the bytes.
                var result = await plc.WriteItemWithValidationAsync(bytesItem);
                Assert.True(result);

                // Write the whole dynamic item.
                result = await plc.WriteItemWithValidationAsync(dynamicTextItem);
                Assert.True(result);
            }
            );
        }