public async Task TestUShort()
{
var data = new byte[10];
const ushort testValue = 30000;
BitConverter.TryWriteBytes(data, testValue);
var tcpDataReader = new TcpDataReader(1024);
await tcpDataReader.NewPackageAsync(data);
var token = new CancellationTokenSource();
var result = await tcpDataReader.ReadUShortAsync(token.Token);
Assert.AreEqual(testValue, result);
}
public async Task TestByteArray()
{
var memoryStream = new MemoryStream();
var testValue = new byte[] { 1, 2, 3, 4, 5, 6 };
memoryStream.WriteByteArray(testValue);
var tcpDataReader = new TcpDataReader(1024);
await tcpDataReader.NewPackageAsync(memoryStream.ToArray());
var token = new CancellationTokenSource();
var result = await tcpDataReader.ReadByteArrayAsync(token.Token);
TestExtensions.AsReadOnlyMemory(testValue).ArrayIsEqualWith(result);
}
public async Task TestInt()
{
var data = new byte[10];
const int testValue = 1234567;
BitConverter.TryWriteBytes(data, testValue);
var tcpDataReader = new TcpDataReader(1024);
await tcpDataReader.NewPackageAsync(data);
var token = new CancellationTokenSource();
var result = tcpDataReader.ReadIntAsync(token.Token).Result;
Assert.AreEqual(testValue, result);
}
public async Task TestString()
{
var memoryStream = new MemoryStream();
const string testValue = "My test String";
memoryStream.WriteString(testValue);
var tcpDataReader = new TcpDataReader(1024);
await tcpDataReader.NewPackageAsync(memoryStream.ToArray());
var tc = new CancellationTokenSource();
var result = await tcpDataReader.ReadStringAsync(tc.Token);
Assert.AreEqual(testValue, result);
}
public async Task TestLong()
{
var data = new byte[10];
const long testValue = 1234567890123;
BitConverter.TryWriteBytes(data, testValue);
var tcpDataReader = new TcpDataReader(1024);
await tcpDataReader.NewPackageAsync(data);
var tc = new CancellationTokenSource();
var result = await tcpDataReader.ReadLongAsync(tc.Token);
Assert.AreEqual(testValue, result);
}
public static async Task NewPackageAsync(this TcpDataReader tcpDataReader, byte[] data)
{
var remainSize = data.Length;
var pos = 0;
while (remainSize > 0)
{
var cancellationToken = new CancellationTokenSource();
var buf = await tcpDataReader.AllocateBufferToWriteAsync(cancellationToken.Token);
var copySize = buf.Length < remainSize ? buf.Length : remainSize;
new ReadOnlyMemory <byte>(data, pos, copySize).CopyTo(buf);
tcpDataReader.CommitWrittenData(copySize);
pos += copySize;
remainSize -= copySize;
}
}
public async Task TestBasicFeature()
{
var trafficReader = new TcpDataReader(1024);
var incomingArray = new byte[] { 1, 2, 3, 4, 5, 6 };
await trafficReader.NewPackageAsync(incomingArray);
var tc = new CancellationTokenSource();
var data = await trafficReader.ReadAsyncAsync(3, tc.Token);
TestExtensions.AsReadOnlyMemory(incomingArray, 0, 3).ArraysAreEqual(data.AsArray());
trafficReader.CommitReadData(data);
data = await trafficReader.ReadAsyncAsync(2, tc.Token);
TestExtensions.AsReadOnlyMemory(incomingArray, 3, 2).ArraysAreEqual(data.AsArray());
trafficReader.CommitReadData(data);
}
public async Task TestSubscribeContract()
{
var serializer = new MyNoSqlTcpSerializer();
var testContract = new SubscribeContract
{
TableName = "Test"
};
var dataReader = new TcpDataReader(ReadBufferSize);
var rawData = serializer.Serialize(testContract);
await dataReader.NewPackageAsync(rawData);
var result
= (SubscribeContract)await serializer
.DeserializeAsync(dataReader, CancellationToken.None);
Assert.AreEqual(testContract.TableName, result.TableName);
}
public async Task TestSizeWithSeveralChunks()
{
var trafficReader = new TcpDataReader(5);
var writeTask = trafficReader.NewPackagesAsync(
new byte[] { 1, 2, 3, 4, 5 },
new byte[] { 6, 7, 8, 9, 10 });
var token = new CancellationTokenSource();
var result1 = await trafficReader.ReadAsyncAsync(7, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3, 4, 5, 6, 7 }).ArrayIsEqualWith(result1.AsArray());
trafficReader.CommitReadData(result1);
var result2 = await trafficReader.ReadAsyncAsync(3, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 8, 9, 10 }).ArrayIsEqualWith(result2.AsArray());
trafficReader.CommitReadData(result2);
await writeTask;
}
public async Task TestPong()
{
var serializer = new MyNoSqlTcpSerializer();
var testContract = new PongContract();
var dataReader = new TcpDataReader(ReadBufferSize);
var rawData = serializer.Serialize(testContract);
await dataReader.NewPackageAsync(rawData);
var tc = new CancellationTokenSource();
var result
= await serializer
.DeserializeAsync(dataReader, tc.Token);
Assert.IsTrue(typeof(PongContract) == result.GetType());
}
public async Task TestOverflowFeature()
{
var trafficReader = new TcpDataReader(1024);
var incomingArray1 = new byte[] { 1, 2, 3, 4, 5, 6 };
var incomingArray2 = new byte[] { 11, 22, 33, 44, 55, 66 };
var writeTask = trafficReader.NewPackagesAsync(incomingArray1, incomingArray2);
var token = new CancellationTokenSource();
var data = await trafficReader.ReadAsyncAsync(3, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
data = await trafficReader.ReadAsyncAsync(4, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 4, 5, 6, 11 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
await writeTask;
}
public async Task TestFindingTheSequenceFeatureByReadingToArraysAtTheEnd()
{
var trafficReader = new TcpDataReader(1024);
var incomingArray1 = new byte[] { 1, 2, 3, 4, 5 };
var incomingArray2 = new byte[] { 11, 12, 13, 4, 5 };
var writingTask = trafficReader.NewPackagesAsync(incomingArray1, incomingArray2);
var tc = new CancellationTokenSource();
var data = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 5, 11 }, tc.Token);
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3, 4, 5, 11 }).ArraysAreEqual(data.AsArray());
trafficReader.CommitReadData(data);
data = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 4, 5 }, tc.Token);
new ReadOnlyMemory <byte>(new byte[] { 12, 13, 4, 5 }).ArraysAreEqual(data.AsArray());
trafficReader.CommitReadData(data);
await writingTask;
}
public async Task TestReadyAmountWayBiggerThenAmountOfBuffer()
{
var dataReader = new TcpDataReader(64);
var list = new List <byte>();
for (byte i = 0; i < 255; i++)
{
list.Add(i);
}
var src = list.ToArray();
var writeTask = dataReader.NewPackageAsync(src);
var result = await dataReader.ReadAsyncAsync(255, new CancellationTokenSource().Token);
src.ArraysAreEqual(result.AsArray());
dataReader.CommitReadData(result);
await writeTask;
}
public async Task TestFindingTheSequenceRightAway()
{
var trafficReader = new TcpDataReader(1024);
var incomingArray1 = new byte[] { 1, 2, 3, 4, 5 };
var incomingArray2 = new byte[] { 11, 12, 13, 4, 5 };
var writeTask = trafficReader.NewPackagesAsync(incomingArray1, incomingArray2);
var token = new CancellationTokenSource();
var data = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 4, 5 }, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3, 4, 5 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
data = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 4, 5 }, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 11, 12, 13, 4, 5 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
await writeTask;
}
public async Task TestSearchWithSeveralChunks()
{
var trafficReader = new TcpDataReader(5);
var writeTask = trafficReader.NewPackagesAsync(
new byte[] { 1, 2, 3, 4, 5 },
new byte[] { 6, 7, 8, 9, 10 }
);
var token = new CancellationTokenSource();
var result1 = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 5, 6 }, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3, 4, 5, 6 }).ArrayIsEqualWith(result1.CommittedMemory);
trafficReader.CommitReadData(result1);
var result2 = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 9, 10 }, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 7, 8, 9, 10 }).ArrayIsEqualWith(result2.UncommittedMemory);
trafficReader.CommitReadData(result1);
await writeTask;
}
public void TestInitPartitionContract()
{
var serializer = new MyNoSqlTcpSerializer();
var testContract = new InitPartitionContract
{
TableName = "Test",
PartitionKey = "PK",
Data = new byte[] { 1, 2, 3 }
};
var rawData = serializer.Serialize(testContract);
var memStream = new MemoryStream(rawData.ToArray())
{
Position = 0
};
var dataReader = new TcpDataReader();
dataReader.NewPackage(memStream.ToArray());
var result
= (InitPartitionContract)serializer
.DeserializeAsync(dataReader)
.AsTestResult();
Assert.AreEqual(testContract.TableName, result.TableName);
Assert.AreEqual(testContract.PartitionKey, result.PartitionKey);
Assert.AreEqual(testContract.Data.Length, result.Data.Length);
for (var i = 0; i < testContract.Data.Length; i++)
{
Assert.AreEqual(testContract.Data[i], result.Data[i]);
}
}
public async Task TestFindingTheSequenceFeatureByReadingToArraysAtTheEndOtherWayAround()
{
var trafficReader = new TcpDataReader(1024);
var token = new CancellationTokenSource();
var dataTask = trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 5, 11 }, token.Token);
var writeTask = trafficReader.NewPackagesAsync(
new byte[] { 1, 2, 3, 4, 5 },
new byte[] { 11, 12, 13, 4, 5 });
var data = await dataTask;
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3, 4, 5, 11 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
data = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 4, 5 }, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 12, 13, 4, 5 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
await writeTask;
}
private async Task ReadLoopAsync(int bufferSize)
{
try
{
var trafficReader = new TcpDataReader(bufferSize);
var trafficWriterTask = PublishDataToTrafficReaderAsync(trafficReader);
while (TcpClient.Connected)
{
try
{
var incomingDataPacket =
await TcpSerializer.DeserializeAsync(trafficReader, _cancellationToken.Token);
await HandleIncomingDataAsync(incomingDataPacket);
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, false);
Log.InvokeInfoLog(this, "Exception on Deserializing or Handling Data in TCP Context Level. Disconnecting");
break;
}
}
await trafficWriterTask;
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, true);
}
finally
{
Log.InvokeInfoLog(this, "Disconnected from ReadLoopAsync");
Disconnect();
}
}
public async Task TestDoubleVeryOverflowFeature()
{
var trafficReader = new TcpDataReader(1024);
var incomingArray1 = new byte[] { 1, 2, 3, 4, 5, 6 };
var incomingArray2 = new byte[] { 11, 22, 33, 44, 55, 66, };
var incomingArray3 = new byte[] { 111, 222, 233, 244, 254, 255 };
var writingTasks = trafficReader.NewPackagesAsync(incomingArray1, incomingArray2, incomingArray3);
var tc = new CancellationTokenSource();
var data = await trafficReader.ReadAsyncAsync(3, tc.Token);
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3 }).ArraysAreEqual(data.AsArray());
trafficReader.CommitReadData(data);
data = await trafficReader.ReadAsyncAsync(10, tc.Token);
new ReadOnlyMemory <byte>(new byte[] { 4, 5, 6, 11, 22, 33, 44, 55, 66, 111 }).ArraysAreEqual(data.AsArray());
trafficReader.CommitReadData(data);
await writingTasks;
}
public async Task TestFindingSequenceWithTwoAsOnePieceAndOtherComplete()
{
var trafficReader = new TcpDataReader(1024);
var token = new CancellationTokenSource();
var dataTask = trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 14, 15 }, token.Token);
var writeTask = trafficReader.NewPackagesAsync(
new byte[] { 1, 2, 3, 4, 5 },
new byte[] { 11, 12, 13, 14, 15 },
new byte[] { 21, 22, 23, 14, 15 });
var data = await dataTask;
new ReadOnlyMemory <byte>(new byte[] { 1, 2, 3, 4, 5, 11, 12, 13, 14, 15 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
data = await trafficReader.ReadWhileWeGetSequenceAsync(new byte[] { 14, 15 }, token.Token);
new ReadOnlyMemory <byte>(new byte[] { 21, 22, 23, 14, 15 }).ArrayIsEqualWith(data.AsArray());
trafficReader.CommitReadData(data);
await writeTask;
}
public async IAsyncEnumerable <IMyNoSqlTcpContract> DeserializeAsync(TcpDataReader dataReader)
{
var result = await SerializerDeserializer.DeserializeAsync(dataReader);
yield return(result);
}
public ValueTask DeserializeAsync(TcpDataReader dataReader)
{
return(new ValueTask());
}
public async ValueTask DeserializeAsync(TcpDataReader dataReader)
{
Name = await dataReader.ReadPascalStringAsync();
}
public async ValueTask DeserializeAsync(TcpDataReader dataReader)
{
TableName = await dataReader.ReadPascalStringAsync();
Data = (await dataReader.ReadByteArrayAsync()).ToArray();
}
public ValueTask <IMyNoSqlTcpContract> DeserializeAsync(TcpDataReader dataReader)
{
return(SerializerDeserializer.DeserializeAsync(dataReader));
}
