public async Task ReadWriteSingles()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB1";
var writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10014, (float)0.0))).ToArray();
var results = (await client.ReadAsync(ReadItem.Create <float>(datablock, 10014))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(float), results[0].Type);
Assert.Equal((float)0.0, (float)results[0].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10014, (float)0.5))).ToArray();
results = (await client.ReadAsync(ReadItem.Create <float>(datablock, 10014))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(float), results[0].Type);
Assert.Equal((float)0.5, (float)results[0].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10014, (float)0.0))).ToArray();
});
}
public async Task ReadWriteMultibleCharsStringLongerThanPDUSize()
{
const string datablock = "DB141";
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var data = new List <ReadItem> {
ReadItem.Create <char[]>(datablock, 28, 14),
ReadItem.Create <char[]>(datablock, 46, 10),
ReadItem.Create <string>(datablock, 106, 10),
ReadItem.Create <char[]>(datablock, 124, 10),
ReadItem.Create <char[]>(datablock, 134, 10),
ReadItem.Create <char[]>(datablock, 60, 8),
ReadItem.Create <char[]>(datablock, 86, 8),
ReadItem.Create <char[]>(datablock, 94, 8),
ReadItem.Create <char[]>(datablock, 116, 8),
ReadItem.Create <char[]>(datablock, 0, 8),
ReadItem.Create <char[]>(datablock, 8, 8),
ReadItem.Create <char[]>(datablock, 16, 8),
ReadItem.Create <char[]>(datablock, 76, 6),
ReadItem.Create <char[]>(datablock, 24, 4),
ReadItem.Create <char[]>(datablock, 42, 4),
ReadItem.Create <char[]>(datablock, 56, 4)
};
var results = (await client.ReadAsync(data)).ToArray();
Assert.Equal(data.Count, results.Length);
Assert.True(results.All(x => x.IsSuccessReturnCode));
var writeResults = await client.WriteAsync(data.Select((r, i) => r.From(results[i].Data)).ToArray());
Assert.Equal(data.Count, writeResults.Count());
Assert.True(writeResults.All(x => x == ItemResponseRetValue.Success));
}, 240);
}
public async Task ReadWriteSingleStrings()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB1";
var writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10046, ""),
WriteItem.Create(datablock, 10068, " "))).ToArray();
var results = (await client.ReadAsync(ReadItem.Create <string>(datablock, 10046, 20),
ReadItem.Create <string>(datablock, 10068, 20))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal(" ", (string)results[1].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10046, "Test1"),
WriteItem.Create(datablock, 10068, "Test2 "))).ToArray();
results = (await client.ReadAsync(ReadItem.Create <string>(datablock, 10046, 20),
ReadItem.Create <string>(datablock, 10068, 20))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("Test1", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal("Test2 ", (string)results[1].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10046, ""),
WriteItem.Create(datablock, 10068, " "))).ToArray();
});
}
public async Task ReadWriteString()
{
const string datablock = "DB962";
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var data0 = new List <WriteItem> {
WriteItem.Create <string>(datablock, 58, 14, "XXXXXXXXXXXXXX")
};
var writeResults1 = await client.WriteAsync(data0);
Assert.Equal(data0.Count, writeResults1.Count());
Assert.True(writeResults1.All(x => x == ItemResponseRetValue.Success));
var data1 = new List <ReadItem> {
ReadItem.Create <string>(datablock, 58, 14)
};
var readResults1 = await client.ReadAsync(data1);
var data = new List <WriteItem> {
WriteItem.Create <string>(datablock, 58, 14, "1234567890ABCD")
};
var writeResults2 = await client.WriteAsync(data);
Assert.Equal(data.Count, writeResults2.Count());
Assert.True(writeResults2.All(x => x == ItemResponseRetValue.Success));
var readResults2 = await client.ReadAsync(data1);
Assert.False(readResults1.FirstOrDefault().Data.Span.SequenceEqual(readResults2.FirstOrDefault().Data.Span));
}, 240);
}
public async Task ReadWriteSingles()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10014,r", (float)0.0 }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(float), results[0].Type);
Assert.Equal((float)0.0, (float)results[0].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10014,r", (float)0.5 }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(float), results[0].Type);
Assert.Equal((float)0.5, (float)results[0].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task CreateMultiWriteTest()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var items = new List <WriteItem>();
var data = new byte[18];
items.Add(WriteItem.Create("DB1993", 8, new byte[86]));
items.Add(WriteItem.Create("DB1993", 2122, new byte[878]));
items.Add(WriteItem.Create("DB1993", 102, new byte[18]));
items.Add(WriteItem.Create("DB1993", 3008, new byte[492]));
items.Add(WriteItem.Create("DB1993", 4122, new byte[378]));
items.Add(WriteItem.Create("DB1993", 122, new byte[18]));
items.Add(WriteItem.Create("DB1993", 14, new byte[86]));
items.Add(WriteItem.Create("DB1993", 722, new byte[78]));
items.Add(WriteItem.Create("DB1993", 1422, new byte[78]));
for (int i = 0; i < 37; i++)
{
items.Add(WriteItem.Create("DB1993", 142 + (i * 20), data));
}
var writeResults = (await client.WriteAsync(items)).ToArray();
});
}
public async Task ReadOfNotExistingBlock()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var x = await client.ReadAsync("DB66.0,B");
});
}
public async Task CreateWriteReferenceTest()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var item = WriteItem.Create("DB210", 192, false);
var writeResults = (await client.WriteAsync(item)).ToArray();
item = WriteItem.Create("DB210", 193, false);
writeResults = (await client.WriteAsync(item)).ToArray();
item = WriteItem.Create("DB210", 35440, false);
writeResults = (await client.WriteAsync(item)).ToArray();
item = WriteItem.Create("DB210", 35441, false);
writeResults = (await client.WriteAsync(item)).ToArray();
item = WriteItem.Create("DB210", 70688, false);
writeResults = (await client.WriteAsync(item)).ToArray();
item = WriteItem.Create("DB210", 70689, false);
writeResults = (await client.WriteAsync(item)).ToArray();
item = WriteItem.Create("DB210", 105936, false);
writeResults = (await client.WriteAsync(item)).ToArray();
item = WriteItem.Create("DB210", 105937, false);
writeResults = (await client.WriteAsync(item)).ToArray();
});
}
public async Task ReadWriteMultibleDInts()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB1";
var writeDataDefault = new int[] { 0, 0 };
const int startAddress = 10038;
var writeResults = (await client.WriteAsync(WriteItem.Create(datablock, startAddress, writeDataDefault))).ToArray();
var results = (await client.ReadAsync(ReadItem.Create <int>(datablock, startAddress, 2))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(int[]), results[0].Type);
var resultValueDefault = results[0].GetValue <int[]>();
Assert.True(resultValueDefault.SequenceEqual(writeDataDefault));
var writeData = new int[] { 22, 21 };
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, startAddress, writeData))).ToArray();
results = (await client.ReadAsync(ReadItem.Create <int>(datablock, startAddress, 2))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(int[]), results[0].Type);
var resultValue = results[0].GetValue <int[]>();
Assert.True(resultValue.SequenceEqual(writeData));
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, startAddress, writeDataDefault))).ToArray();
});
}
public async Task ReadWriteBigDBData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var data = Enumerable.Repeat((byte)0x00, 1000).ToArray();
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.2500,b,1000", data }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.True(results.FirstOrDefault().Data.ToArray().SequenceEqual(data));
var data2 = Enumerable.Repeat((byte)0x25, 1000).ToArray();
var writeTags = new Dictionary <string, object>
{
{ $"DB2.2500,b,1000", data2 }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.True(results.FirstOrDefault().Data.ToArray().SequenceEqual(data2));
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteSingleWords()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB1";
var writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10002, (ushort)0),
WriteItem.Create(datablock, 10004, (short)0))).ToArray();
var results = (await client.ReadAsync(ReadItem.Create <ushort>(datablock, 10002),
ReadItem.Create <short>(datablock, 10004))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(ushort), results[0].Type);
Assert.Equal((ushort)0, (ushort)results[0].Value);
Assert.Equal(typeof(short), results[1].Type);
Assert.Equal((short)0, (short)results[1].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10002, (ushort)15),
WriteItem.Create(datablock, 10004, (short)25))).ToArray();
results = (await client.ReadAsync(ReadItem.Create <ushort>(datablock, 10002),
ReadItem.Create <short>(datablock, 10004))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(ushort), results[0].Type);
Assert.Equal((ushort)15, (ushort)results[0].Value);
Assert.Equal(typeof(short), results[1].Type);
Assert.Equal((short)25, (short)results[1].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, 10002, (ushort)0),
WriteItem.Create(datablock, 10004, (short)0))).ToArray();
});
}
public async Task ReadMetadataOfNotExistingBlock()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var x = await client.ReadBlockInfoAsync(PlcBlockType.Db, 66);
Assert.Equal(0, x.CodeSize);
});
}
public async Task ReadWriteDataAndCheckIfTheResultsDontChangeBecauseOfBufferReusing()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB4";
const ushort offset = 2500;
var resultsDefault0 = new Memory <byte>(Enumerable.Repeat((byte)0x00, 1000).ToArray());
var resultsDefault1 = await client.WriteAsync(WriteItem.Create(datablock, offset, resultsDefault0));
var resultsDefault2 = (await client.ReadAsync(ReadItem.Create <byte[]>(datablock, offset, 1000)));
var first = resultsDefault2.FirstOrDefault();
var copy1 = new byte[first.Data.Length];
first.Data.CopyTo(copy1);
Assert.True(resultsDefault0.Span.SequenceEqual(first.Data.Span), "1");
Assert.True(resultsDefault0.Span.SequenceEqual(copy1), "2");
var results0 = new Memory <byte>(Enumerable.Repeat((byte)0x25, 1000).ToArray());
var results1 = await client.WriteAsync(WriteItem.Create(datablock, offset, results0));
var results2 = (await client.ReadAsync(ReadItem.Create <byte[]>(datablock, offset, 1000)));
var second = results2.FirstOrDefault();
var copy2 = new byte[second.Data.Length];
second.Data.CopyTo(copy2);
resultsDefault1 = await client.WriteAsync(WriteItem.Create(datablock, offset, resultsDefault0));
Assert.True(results0.Span.SequenceEqual(results2.FirstOrDefault().Data.Span), "3");
Assert.True(results0.Span.SequenceEqual(copy2), "4");
var results00 = new Memory <byte>(Enumerable.Repeat((byte)0x01, 1000).ToArray());
var results01 = await client.WriteAsync(WriteItem.Create(datablock, offset, results00));
var results02 = (await client.ReadAsync(ReadItem.Create <byte[]>(datablock, offset, 1000)));
var third = results02.FirstOrDefault();
var copy3 = new byte[third.Data.Length];
third.Data.CopyTo(copy3);
resultsDefault1 = await client.WriteAsync(WriteItem.Create(datablock, offset, resultsDefault0));
Assert.True(results00.Span.SequenceEqual(results02.FirstOrDefault().Data.Span), "5");
Assert.True(results00.Span.SequenceEqual(copy3), "6");
Assert.True(resultsDefault0.Span.SequenceEqual(first.Data.Span), "7");
Assert.True(resultsDefault0.Span.SequenceEqual(copy1), "8");
Assert.True(first.Data.Span.SequenceEqual(copy1), "9");
Assert.True(results0.Span.SequenceEqual(second.Data.Span), "10");
Assert.True(results0.Span.SequenceEqual(copy2), "11");
Assert.True(second.Data.Span.SequenceEqual(copy2), "12");
Assert.True(results00.Span.SequenceEqual(third.Data.Span), "13");
Assert.True(results00.Span.SequenceEqual(copy3), "14");
Assert.True(third.Data.Span.SequenceEqual(copy3), "15");
});
}
public async Task WriteString()
{
const string datablock = "DB962";
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var data = new List <WriteItem> {
WriteItem.Create <string>(datablock, 12, 8, "12345678")
};
var writeResults = await client.WriteAsync(data);
Assert.Equal(data.Count, writeResults.Count());
Assert.True(writeResults.All(x => x == ItemResponseRetValue.Success));
}, 240);
}
public async Task ReadMixedData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var results = (await client.ReadAsync(ReadItem.CreateFromTag("DB1.4,B,8"),
ReadItem.CreateFromTag("DB1.38,B,8"),
ReadItem.CreateFromTag("DB1.94,B,10"))).ToArray();
Assert.Equal(3, results.Count());
Assert.True(results[0].IsSuccessReturnCode);
Assert.True(results[1].IsSuccessReturnCode);
Assert.True(results[2].IsSuccessReturnCode);
});
}
// DB2241.0,B,15450
public async Task WriteBigDBData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var data = Enumerable.Repeat((byte)0x00, 15450).ToArray();
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2241.0,b,15450", data }
};
var writeResults = (await client.WriteAsync(originWriteTags)).ToArray();
Assert.Equal(ItemResponseRetValue.DataError, writeResults[0]);
var results = (await client.ReadAsync(originWriteTags.Keys)).ToArray();
Assert.Equal(ItemResponseRetValue.DataError, results[0].ReturnCode);
});
}
public async Task ReadMultibleByteArrayData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB1";
var results = (await client.ReadAsync(ReadItem.Create <byte[]>(datablock, 0, 1000),
ReadItem.Create <byte[]>(datablock, 2200, 100),
ReadItem.Create <byte[]>(datablock, 1000, 1000),
ReadItem.Create <byte[]>(datablock, 200, 100))).ToArray();
Assert.Equal(4, results.Count());
Assert.Equal(1000, results[0].Data.Length);
Assert.Equal(100, results[1].Data.Length);
Assert.Equal(1000, results[2].Data.Length);
Assert.Equal(100, results[3].Data.Length);
});
}
public async Task ReadWriteBigDBData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB1";
const ushort offset = 2500;
var resultsDefault0 = new Memory <byte>(Enumerable.Repeat((byte)0x00, 1000).ToArray());
var resultsDefault1 = await client.WriteAsync(WriteItem.Create(datablock, offset, resultsDefault0));
var resultsDefault2 = (await client.ReadAsync(ReadItem.Create <byte[]>(datablock, offset, 1000)));
var results0 = new Memory <byte>(Enumerable.Repeat((byte)0x25, 1000).ToArray());
var results1 = await client.WriteAsync(WriteItem.Create(datablock, offset, results0));
var results2 = (await client.ReadAsync(ReadItem.Create <byte[]>(datablock, offset, 1000)));
resultsDefault1 = await client.WriteAsync(WriteItem.Create(datablock, offset, resultsDefault0));
Assert.True(results0.Span.SequenceEqual(results2.FirstOrDefault().Data.Span));
});
}
public async Task ReadMixedData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.4,B,8", null },
{ $"DB2.38,B,8", null },
{ $"DB2.94,B,10", null },
};
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(3, results.Count());
Assert.True(results[0].IsSuccessReturnCode);
Assert.True(results[1].IsSuccessReturnCode);
Assert.True(results[2].IsSuccessReturnCode);
});
}
public async Task WriteMultiCharsAndString()
{
const string datablock = "DB962";
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var data = new List <WriteItem> {
WriteItem.Create <char[]>(datablock, 60, 14, "|010101010101|".ToCharArray()),
WriteItem.Create <char[]>(datablock, 2, 10, "|01010101|".ToCharArray()),
WriteItem.Create <string>(datablock, 12, 8, "|123456|"),
WriteItem.Create <char[]>(datablock, 36, 6, "|1234|".ToCharArray()),
WriteItem.Create <char[]>(datablock, 24, 4, "|12|".ToCharArray()),
WriteItem.Create <char[]>(datablock, 30, 4, "|12|".ToCharArray()),
WriteItem.Create <char[]>(datablock, 44, 4, "|12|".ToCharArray())
};
var writeResults = await client.WriteAsync(data);
Assert.Equal(data.Count, writeResults.Count());
Assert.True(writeResults.All(x => x == ItemResponseRetValue.Success));
}, 240);
}
public async Task ReadWriteSingleBits()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10000,x0", false },
{ $"DB2.10000,x5", false }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(bool), results[0].Type);
Assert.False((bool)results[0].Value);
Assert.Equal(typeof(bool), results[1].Type);
Assert.False((bool)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10000,x0", true },
{ $"DB2.10000,x5", true }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(bool), results[0].Type);
Assert.True((bool)results[0].Value);
Assert.Equal(typeof(bool), results[1].Type);
Assert.True((bool)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteSingleDWords()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10006,dw", (uint)0 },
{ $"DB2.10010,di", 0 }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(uint), results[0].Type);
Assert.Equal((uint)0, (uint)results[0].Value);
Assert.Equal(typeof(int), results[1].Type);
Assert.Equal(0, (int)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10006,dw", (uint)15 },
{ $"DB2.10010,di", 25 }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(uint), results[0].Type);
Assert.Equal((ushort)15, (uint)results[0].Value);
Assert.Equal(typeof(int), results[1].Type);
Assert.Equal(25, (int)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadMultibleByteArrayData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var readTags = new Dictionary <string, object>
{
{ $"DB2.0,b,1000", 1000 },
{ $"DB2.2200,b,100", 100 },
{ $"DB2.1000,b,1000", 1000 },
{ $"DB2.200,b,100", 100 },
};
var results = (await client.ReadAsync(readTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(4, results.Count());
Assert.Equal(1000, results[0].Data.Length);
Assert.Equal(100, results[1].Data.Length);
Assert.Equal(1000, results[2].Data.Length);
Assert.Equal(100, results[3].Data.Length);
});
}
public async Task ReadWriteSingleStrings()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10046,s,20", "" },
{ $"DB2.10068,s,20", " " }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal(" ", (string)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10046,s,20", "Test1" },
{ $"DB2.10068,s,20", "Test2 " }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("Test1", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal("Test2 ", (string)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteSingleStrings2()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10090,s,20", "" },
{ $"DB2.10112,s,20", " " }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal(" ", (string)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10046,s,20", "A PARTIAL STRING".PadLeft(20).Substring(0, 18) },
{ $"DB2.10068,s,20", "A FULLY STRING IT IS".PadLeft(20) }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("A PARTIAL STRING".PadLeft(20).Substring(0, 18), (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal("A FULLY STRING IT IS".PadLeft(20), (string)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteMultibleDWords()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10034,dw,2", new uint[] { 0, 0 } }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(uint[]), results[0].Type);
var resultValueDefault = results[0].Value as uint[];
Assert.True(resultValueDefault.SequenceEqual(originWriteTags.FirstOrDefault().Value as uint[]));
var writeData = new uint[] { 22, 21 };
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10034,dw,2", writeData }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(uint[]), results[0].Type);
var resultValue = results[0].Value as uint[];
Assert.True(resultValue.SequenceEqual(writeData));
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteMultibleDInts()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10038,di,2", new int[] { 0, 0 } }
};
var writeResults = (await client.WriteAsync(originWriteTags)).ToArray();
var results = (await client.ReadAsync(originWriteTags.Keys)).ToArray();
Assert.Single(results);
Assert.Equal(typeof(int[]), results[0].Type);
var resultValueDefault = results[0].GetValue <int[]>();
Assert.True(resultValueDefault.SequenceEqual(originWriteTags.FirstOrDefault().Value as int[]));
var writeData = new int[] { 22, 21 };
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10038,di,2", writeData }
};
writeResults = (await client.WriteAsync(writeTags)).ToArray();
results = (await client.ReadAsync(writeTags.Keys)).ToArray();
Assert.Single(results);
Assert.Equal(typeof(int[]), results[0].Type);
var resultValue = results[0].GetValue <int[]>();
Assert.True(resultValue.SequenceEqual(writeData));
writeResults = (await client.WriteAsync(originWriteTags)).ToArray();
});
}
public async Task ReadWriteSingleWords()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10002,w", (ushort)0 },
{ $"DB2.10004,i", (short)0 }
};
var writeResults = (await client.WriteAsync(originWriteTags)).ToArray();
var results = (await client.ReadAsync(originWriteTags.Keys)).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(ushort), results[0].Type);
Assert.Equal((ushort)0, (ushort)results[0].Value);
Assert.Equal(typeof(short), results[1].Type);
Assert.Equal((short)0, (short)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10002,w", (ushort)15 },
{ $"DB2.10004,i", (short)25 }
};
writeResults = (await client.WriteAsync(writeTags)).ToArray();
results = (await client.ReadAsync(writeTags.Keys)).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(ushort), results[0].Type);
Assert.Equal((ushort)15, (ushort)results[0].Value);
Assert.Equal(typeof(short), results[1].Type);
Assert.Equal((short)25, (short)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags)).ToArray();
});
}
public async Task ReadWriteSingleBits()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
const string datablock = "DB1";
var baseOffset = 10000 * 8;
var writeResults = (await client.WriteAsync(WriteItem.Create(datablock, baseOffset, false),
WriteItem.Create(datablock, baseOffset + 5, false))).ToArray();
var results = (await client.ReadAsync(ReadItem.Create <bool>(datablock, baseOffset),
ReadItem.Create <bool>(datablock, baseOffset + 5))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(bool), results[0].Type);
Assert.False((bool)results[0].Value);
Assert.Equal(typeof(bool), results[1].Type);
Assert.False((bool)results[1].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, baseOffset, true),
WriteItem.Create(datablock, baseOffset + 5, true))).ToArray();
results = (await client.ReadAsync(ReadItem.Create <bool>(datablock, baseOffset),
ReadItem.Create <bool>(datablock, baseOffset + 5))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(bool), results[0].Type);
Assert.True((bool)results[0].Value);
Assert.Equal(typeof(bool), results[1].Type);
Assert.True((bool)results[1].Value);
writeResults = (await client.WriteAsync(WriteItem.Create(datablock, baseOffset, false),
WriteItem.Create(datablock, baseOffset + 5, false))).ToArray();
});
}
