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