public void Send_WhenReceiveNAK_2ndTime_ShouldTryAgain() { using (var stream = new RWStream()) using (var sut = new StreamRawPinPad(stream)) { var payload = Encoding.ASCII.GetBytes("OPN000"); var expectedBytes = new ByteArrayBuilder() .Add(Bytes.SYN).Add(payload).Add(Bytes.ETB).Add(0x77, 0x5e) .Add(Bytes.SYN).Add(payload).Add(Bytes.ETB).Add(0x77, 0x5e) .Add(Bytes.SYN).Add(payload).Add(Bytes.ETB).Add(0x77, 0x5e) .Add(Bytes.CAN) .ToArray(); Should.CompleteIn(async() => { var taskSend = sut.SendRawMessageAsync(new RawRequestMessage(payload)); await Task.Delay(100); stream.PushByteToRead(Bytes.NAK); await Task.Delay(100); stream.PushByteToRead(Bytes.NAK); await taskSend; }, TimeSpan.FromMilliseconds(100 + 100 + TimeoutMilliseconds + ToleranceMilliseconds)); stream.GetBytesWritten().ShouldBe(expectedBytes); } }
public void Locks_Only_Modified_Tables_When_Different_datalyer() { using (var application = SequenceGeneratorModule().Application){ var defaultDataLayer1 = NewSimpleDataLayer(application); var explicitUnitOfWork = new ExplicitUnitOfWork(defaultDataLayer1); var testObject = new TestObject(explicitUnitOfWork); explicitUnitOfWork.FlushChanges(); var defaultDataLayer2 = NewSimpleDataLayer(application); var explicitUnitOfWork1 = new ExplicitUnitOfWork(defaultDataLayer2); var testObject2 = new TestObject2(explicitUnitOfWork1); explicitUnitOfWork1.FlushChanges(); Should.Throw <ShouldCompleteInException>(() => Should.CompleteIn( () => explicitUnitOfWork.GetObjectByKey <TestObject2>(testObject2.Oid).ShouldNotBeNull(), TimeSpan.FromSeconds(1))); Should.Throw <ShouldCompleteInException>(() => Should.CompleteIn( () => explicitUnitOfWork1.GetObjectByKey <TestObject>(testObject.Oid).ShouldNotBeNull(), TimeSpan.FromSeconds(1))); explicitUnitOfWork.Close(); defaultDataLayer1.Dispose(); explicitUnitOfWork1.Close(); defaultDataLayer2.Dispose(); } }
public async Task TokenCancelled_VerifySocketDisposed() { var mock = Substitute.For <WebSocket>(); mock.State.Returns(WebSocketState.Open); var cancelled = new CancellationToken(true); var receiveResultSource = new TaskCompletionSource <ValueWebSocketReceiveResult>(); mock.ReceiveAsync(Arg.Any <Memory <byte> >(), Arg.Any <CancellationToken>()) .Returns(new ValueTask <ValueWebSocketReceiveResult>(receiveResultSource.Task)); var closeOutputResultSource = new TaskCompletionSource <bool>(); mock.CloseOutputAsync(Arg.Any <WebSocketCloseStatus>(), Arg.Any <string>(), cancelled) .Returns(closeOutputResultSource.Task); var rxSocket = new RxWebSocket(mock); rxSocket.Sender.Complete(); Should.CompleteIn(rxSocket.SendCompletion, timeout); var closeTask = rxSocket.CloseAsync(cancelled); mock.State.Returns(WebSocketState.Aborted); closeOutputResultSource.SetCanceled(); receiveResultSource.SetCanceled(); Should.CompleteIn(closeTask, timeout); await mock.Received(1).CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancelled); }
public void ShouldCompleteIn() { DocExampleWriter.Document(() => { Should.CompleteIn(() => Thread.Sleep(TimeSpan.FromSeconds(2)), TimeSpan.FromSeconds(1), "Some additional context"); }, _testOutputHelper); }
public async Task RxWebSocket_ReceiveMessage() { using (var rxSocket = new RxWebSocket(await this.CreateAndConnectSocket())) { var message = Should.CompleteIn(rxSocket.ToObservable().FirstAsync().ToTask(), timeout); } }
public void receiver_should_complete() { // Arrange var mock = Substitute.For <WebSocket>(); mock.State.Returns(WebSocketState.Open); var receiveResultSource = new TaskCompletionSource <ValueWebSocketReceiveResult>(); mock.ReceiveAsync(Arg.Any <Memory <byte> >(), Arg.Any <CancellationToken>()) .Returns(new ValueTask <ValueWebSocketReceiveResult>(receiveResultSource.Task)); var rxWebSocket = new RxWebSocket(mock); rxWebSocket.Receiver.Completion.IsCompleted.ShouldBeFalse(); // Act mock.State.Returns(WebSocketState.Closed); mock.CloseStatus.Returns(WebSocketCloseStatus.NormalClosure); mock.CloseStatusDescription.Returns(string.Empty); receiveResultSource.SetResult(new ValueWebSocketReceiveResult(0, WebSocketMessageType.Close, true)); // Assert Should.CompleteIn(rxWebSocket.Receiver.Completion, TimeSpan.FromMilliseconds(100)); }
public void socket_should_be_disposed() { // Arrange var mock = Substitute.For <WebSocket>(); mock.State.Returns(WebSocketState.Open); var receiveResultSource = new TaskCompletionSource <ValueWebSocketReceiveResult>(); mock.ReceiveAsync(Arg.Any <Memory <byte> >(), default) .ReturnsForAnyArgs(new ValueTask <ValueWebSocketReceiveResult>(receiveResultSource.Task)); var rxWebSocket = new RxWebSocket(mock); rxWebSocket.Receiver.Completion.IsCompleted.ShouldBeFalse(); TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(); mock.When(s => s.Dispose()).Do(c => tcs.SetResult(true)); // Act mock.State.Returns(WebSocketState.Closed); mock.CloseStatus.Returns(WebSocketCloseStatus.NormalClosure); mock.CloseStatusDescription.Returns(string.Empty); receiveResultSource.SetResult(new ValueWebSocketReceiveResult(0, WebSocketMessageType.Close, true)); Should.CompleteIn(tcs.Task, TimeSpan.FromMilliseconds(1000)); mock.Received(1).Dispose(); }
public void sending_should_complete() { // Arrange var mock = Substitute.For <WebSocket>(); mock.State.Returns(WebSocketState.Open); var closeTrigger = mock.ReceiveNormalClosure(); var rxWebSocket = new RxWebSocket(mock); rxWebSocket.Receiver.Completion.IsCompleted.ShouldBeFalse(); // Act closeTrigger(); mock.State.Returns(WebSocketState.Closed); mock.SendAsync(Arg.Any <ReadOnlyMemory <byte> >(), Arg.Any <WebSocketMessageType>(), Arg.Any <bool>(), Arg.Any <CancellationToken>()) .Throws(new ObjectDisposedException(null)); Should.CompleteIn(Assert.ThrowsAsync <TaskCanceledException>(() => rxWebSocket.SendCompletion), TimeSpan.FromMilliseconds(100)); // Assert rxWebSocket.Sender.TryWrite(new Message(MessageType.Text, Array.Empty <byte>())).ShouldBeFalse(); }
public async Task after_send_completion_should_succeed() { var mock = Substitute.For <WebSocket>(); mock.State.Returns(WebSocketState.Open); var closeTrigger = mock.ReceiveNormalClosure(); var closeOutputResultSource = new TaskCompletionSource <bool>(); mock.CloseOutputAsync(Arg.Any <WebSocketCloseStatus>(), Arg.Any <string>(), Arg.Any <CancellationToken>()) .Returns(closeOutputResultSource.Task); void closeOutputTrigger() { closeOutputResultSource.SetResult(true); mock.State.Returns(WebSocketState.CloseSent); closeTrigger(); } var rxSocket = new RxWebSocket(mock); rxSocket.Sender.Complete(); Should.CompleteIn(rxSocket.SendCompletion, timeout); var closeTask = rxSocket.CloseAsync(this.cts.Token); closeOutputTrigger(); Should.CompleteIn(closeTask, timeout); await mock.Received(1).CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, this.cts.Token); }
public void FractionalKnapsack_MultipleItems() { //var numberOfItems = 3; var capacityOfKnapsack = 50; var valAndWeightArr = new[] { new ValueAndWeight { Value = 60, Weight = 20 }, new ValueAndWeight { Value = 100, Weight = 50 }, new ValueAndWeight { Value = 120, Weight = 30 }, }; var f0 = new Launcher(); f0.FractionalKnapsackCalculator(capacityOfKnapsack, valAndWeightArr).ShouldBe(180.0000); Should.CompleteIn( () => f0.FractionalKnapsackCalculator(capacityOfKnapsack, valAndWeightArr), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public async Task RxWebSocket_CompleteSender_ShouldCompleteTask() { using (var rxSocket = new RxWebSocket(await this.CreateAndConnectSocket())) { rxSocket.Sender.Complete(); Should.CompleteIn(rxSocket.SendCompletion, timeout); } }
public void CanSendMessagesOfAllTypes() { var received = new List <TransportMessage>(); var serverTask = RunReceiverTaskAsync(() => _server.In.ReadAsync(), async receiver => { while (true) { var maybeMessage = await receiver.In.TryReadAsync().ConfigureAwait(false); if (!maybeMessage.HasValue) { Log.Trace("Receving terminated for stream {0}", receiver.Id); break; } Log.Trace("Received message from stream {0}: {1}", receiver.Id, maybeMessage.Value); received.Add(maybeMessage.Value); } await receiver.In.Completion.ConfigureAwait(false); }); var testMessages = GenerateAllTransportMessages().ToArray(); var clientTask = RunSenderTaskAsync(() => _client.ConnectAsync(BrokerWorkingDir), async sender => { foreach (var transportMessage in testMessages) { transportMessage.Retain(); await sender.Out.WriteAsync(transportMessage).ConfigureAwait(false); } sender.Out.TryComplete(); await sender.Out.Completion.ConfigureAwait(false); }); Should.CompleteIn(Task.WhenAll(clientTask, serverTask), Timeout1Sec); received.Count.ShouldBe(5); using (var enumerator = received.GetEnumerator()) { foreach (var expected in testMessages) { using (expected) { enumerator.MoveNext().ShouldBe(true); using (var actual = enumerator.Current) { actual.Header.ShouldBe(expected.Header); actual.Payload.HasValue.ShouldBe(expected.Payload.HasValue); if (expected.Payload.HasValue) { var actualPayload = actual.Payload.Value.ToArray(); var expectedPayload = expected.Payload.Value.ToArray(); actualPayload.ShouldBe(expectedPayload); } } } } } }
public void ReadsSynchronouslyWhenThereIsPendingWriteTask() { var sut = new BufferedChannel <int>(0); var writeTask = sut.WriteAsync(3); sut.TryReadSafe(out int item).ShouldBe(true); item.ShouldBe(3); Should.CompleteIn(writeTask, TimeSpan.FromSeconds(1)); }
public void ShouldCompleteIn() { DocExampleWriter.Document(() => { Should.CompleteIn( action: () => { Thread.Sleep(TimeSpan.FromSeconds(2)); }, timeout: TimeSpan.FromSeconds(1), customMessage: "Some additional context"); }, _testOutputHelper); }
public void The_initial_query_doesnt_block_construction() { _client.GetAllToggles().Returns(ci => { Thread.Sleep(TimeSpan.FromSeconds(2)); return(_toggles); }); Should.CompleteIn(() => CreateFetcher(), TimeSpan.FromSeconds(1)); }
public void WritesSynchronouslyWhenThereIsPendingReadTask() { var sut = new BufferedChannel <int>(0); var readTask = sut.ReadAsync(); sut.TryWriteSafe(1).ShouldBe(false); sut.WriteAsync(1).ShouldCompleteIn(Timeout1Sec); Should.CompleteIn(readTask.AsTask(), TimeSpan.FromSeconds(1)); readTask.Result.ShouldBe(1); }
public void BinarySearch_GameOn(long[] data, long[] searchTerms, string expected) { var f0 = new Launcher(); f0.BinarySearchSetup(data, searchTerms).ShouldBe(expected); Should.CompleteIn( () => f0.BinarySearchSetup(data, searchTerms), TimeSpan.FromMilliseconds(10)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void Fibonacci(long input, int expected) { var f0 = new Launcher(); f0.CalculateFibonacciLastDigit(input).ShouldBe(expected); Should.CompleteIn( () => f0.CalculateFibonacciLastDigit(input), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void timedResult_Test() { var testor = new TestorTheBarbarian(); //set sleep to >1000 to fail test var sleepyTime = 500; //nunit closest option MaxTime attribute on the test method. Should.CompleteIn( () => testor.Rest(sleepyTime), TimeSpan.FromSeconds(1) ); //--> Task should complete in 00:00:01 but did not }
public void Test_1(long[] first, long[] second, long expected) { var f0 = new Launcher(); f0.ComputeMinDotProduct(first, second).ShouldBe(expected); Should.CompleteIn( () => f0.ComputeMinDotProduct(first, second), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void Test_1(long[] inputLongs, long expected) { var f0 = new Launcher(); f0.CalculateGcd(inputLongs).ShouldBe(expected); Should.CompleteIn( () => f0.CalculateGcd(inputLongs), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void AAA_CheckingBrackets(string input, string expected) { var f0 = new Launcher(); f0.BracketsBalanced(input).ShouldBe(expected); Should.CompleteIn( () => f0.BracketsBalanced(input), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void Test_1(int input, int expected) { var f0 = new Launcher(); f0.MinimumNumberOfCoinsToChangeMoney(input).ShouldBe(expected); Should.CompleteIn( () => f0.MinimumNumberOfCoinsToChangeMoney(input), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void WriteAsyncCompletesWhenThereIsBufferSpaceAvailable() { var sut = new BufferedChannel <int>(1); Should.CompleteIn(sut.WriteAsync(1), Timeout1Sec); var writeTask = sut.WriteAsync(2); writeTask.IsCompleted.ShouldBe(false); sut.TryRead(out var item).ShouldBe(true); item.ShouldBe(1); Should.CompleteIn(writeTask, Timeout1Sec); sut.TryRead(out item).ShouldBe(true); item.ShouldBe(2); }
public void WaitForPermission_ShouldNotWait_IfOperationIsCancelled() { const int REQUESTS_PER_PERIOD = 1; const int TIME_FRAME_MS = 30000; const int TOLERABLE_TIME_AFTER_CANCELLING_MS = 5000; _throttler = new Throttler(REQUESTS_PER_PERIOD, TIME_FRAME_MS, true); _throttler.WaitForPermission(); var cancellationToken = new CancellationToken(true); Should.CompleteIn(() => _throttler.WaitForPermission(cancellationToken), TimeSpan.FromMilliseconds(TOLERABLE_TIME_AFTER_CANCELLING_MS)); }
public void QuickSortTestCases(string caseName, long[] input, long[] expected) { var f0 = new Launcher(); var inputMaxIndex = input.Length - 1; f0.QuickSort(input, 0, inputMaxIndex); input.ShouldBe(expected); Should.CompleteIn( () => f0.QuickSort(input, 0, inputMaxIndex), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void KnapNoRep(string testCase, int knapsackCapacity, int[] weights, int[] values, int expectedValue) { weights.Length.ShouldBe(values.Length); var f0 = new Launcher(); f0.KnapsackNoRep(knapsackCapacity, weights, values).ShouldBe(expectedValue); Should.CompleteIn( () => f0.KnapsackNoRep(knapsackCapacity, weights, values), TimeSpan.FromMilliseconds(1500)); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void FailCompletesChannelEvenIfBufferIsNotEmpty() { var sut = new BufferedChannel <int>(2); sut.TryWriteSafe(1); sut.TryWriteSafe(2); sut.Terminate(new InvalidOperationException()); sut.Completion.IsCompleted.ShouldBe(false); sut.TryReadSafe(out int _).ShouldBe(true); sut.TryReadSafe(out int _).ShouldBe(true); var result = Should.CompleteIn(() => sut.TryReadSafeAsync().AsTask(), TimeSpan.FromSeconds(1)); result.HasValue.ShouldBeFalse(); sut.Completion.IsFaulted.ShouldBeTrue(); }
public void Fibonacci(long input, long expected) { var f0 = new Launcher(); f0.CalculateFibonacci(input).ShouldBe(expected); Should.CompleteIn( () => f0.CalculateFibonacci(input), TimeSpan.FromMilliseconds(1500)); // not correct...? Off by a couple orders of magnitude. Answer on instructor machine: 8667136/536870912 //long memory = GC.GetTotalMemory(true); //memory.ShouldBe(15); var proc = Process.GetCurrentProcess(); proc.PrivateMemorySize64.ShouldBeLessThanOrEqualTo(512 * 1000 * 1000); }
public void Send_WhenDoesNotReceiveReplyAndTimeout_ShouldAddCANandAbort() { using (var stream = new RWStream()) using (var sut = new StreamRawPinPad(stream)) { var payload = Encoding.ASCII.GetBytes("OPN000"); var expectedBytes = new ByteArrayBuilder() .Add(Bytes.SYN).Add(payload).Add(Bytes.ETB).Add(0x77, 0x5e) .Add(Bytes.CAN) .ToArray(); Should.CompleteIn(async() => { await sut.SendRawMessageAsync(new RawRequestMessage(payload)); }, TimeSpan.FromMilliseconds(TimeoutMilliseconds + ToleranceMilliseconds)); stream.GetBytesWritten().ShouldBe(expectedBytes); } }