public async Task TestAwaitTimeoutAndReceivedResult() { var x = new ResultCallback(); Assert.False((bool)await x.Wait(TimeSpan.FromMilliseconds(100))); x.ReceivedResult(CallTransmissionResponseType.Exception, null, 0); //no exception }
public async Task TestReceivedResultAfterDispose() { var x = new ResultCallback(); Assert.False(await x.Wait(TimeSpan.FromMilliseconds(50))); x.Dispose(); x.ReceivedResult(CallTransmissionResponseType.MethodExecuted, null, 0); }
public async Task TestAwaitWorks() { var testData = new byte[12]; StaticRandom.NextBytes(testData); var x = new ResultCallback(); await Task.Delay(TimeSpan.FromMilliseconds(50)) .ContinueWith(task => x.ReceivedResult(CallTransmissionResponseType.MethodExecuted, testData, 4)); await x.Wait(TimeSpan.FromSeconds(1)); Assert.Equal(CallTransmissionResponseType.MethodExecuted, x.ResponseType); Assert.Equal(testData, x.Data); Assert.Equal(4, x.Offset); }
private async Task <object> SendMethodCall(MethodCache methodCache, object[] parameters) { if (methodCache == null) { throw new ArgumentException("The parameter cannot be null.", nameof(methodCache)); } if (methodCache == null) { throw new ArgumentException("The parameter cannot be null.", nameof(parameters)); } //PROTOCOL //CALL: //HEAD - 4 bytes - Identifier, ASCII (NTC1) //HEAD - integer - callback identifier //HEAD - uinteger - The method identifier //HEAD - integer * parameters - the length of each parameter //-------------------------------------------------------------------------- //DATA - length of the parameters - serialized parameters var callbackId = (uint)Interlocked.Increment(ref _callIdCounter); var buffer = new byte[CustomOffset /* user offset */ + 4 /* Header */ + 4 /* Callback id */ + 4 /* method id */ + parameters.Length * 4 /* parameter meta */ + EstimatedDataPerParameter * parameters.Length /* parameter data */]; var bufferOffset = CustomOffset + 12 + parameters.Length * 4; for (var i = 0; i < parameters.Length; i++) { var metaOffset = CustomOffset + 12 + i * 4; var parameterLength = _serializer.Serialize(methodCache.ParameterTypes[i], ref buffer, bufferOffset, parameters[i]); Buffer.BlockCopy(BitConverter.GetBytes(parameterLength), 0, buffer, metaOffset, 4); bufferOffset += parameterLength; } //write header buffer[CustomOffset] = CallProtocolInfo.Header1; buffer[CustomOffset + 1] = CallProtocolInfo.Header2; buffer[CustomOffset + 2] = CallProtocolInfo.Header3Call; buffer[CustomOffset + 3] = CallProtocolInfo.Header4; //write callback id Buffer.BlockCopy(BitConverter.GetBytes(callbackId), 0, buffer, CustomOffset + 4, 4); //method identifier Buffer.BlockCopy(BitConverter.GetBytes(methodCache.MethodId), 0, buffer, CustomOffset + 8, 4); var callback = new ResultCallback(); var callbackWait = callback.Wait(WaitTimeout); _callbacks.TryAdd(callbackId, callback); //impossible that this goes wrong OnSendData(new ArraySegment <byte>(buffer, 0, bufferOffset)).Forget(); //no need to await that using (callback) { if (!await callbackWait.ConfigureAwait(false)) { _callbacks.TryRemove(callbackId, out var _); throw new TimeoutException("The method call timed out, no response received."); } switch (callback.ResponseType) { case CallTransmissionResponseType.MethodExecuted: return(null); case CallTransmissionResponseType.ResultReturned: return(_serializer.Deserialize(methodCache.ReturnType, callback.Data, callback.Offset)); case CallTransmissionResponseType.Exception: var up = _serializer.DeserializeException(callback.Data, callback.Offset); throw up; case CallTransmissionResponseType.MethodNotImplemented: throw new NotImplementedException("The remote method is not implemented."); default: throw new ArgumentOutOfRangeException(); } } }
public async Task TestWaitTimeout() { var x = new ResultCallback(); Assert.False(await x.Wait(TimeSpan.FromMilliseconds(200))); }