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