public void CompleteAfterMessages() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 5); var task1 = writer.WriteAsync("1"); var task2 = writer.WriteAsync("2"); var completionTask = writer.WriteCompleteAsync(); AssertNotCompleted(task1, task2, completionTask); // Server handles first message fake.CompleteCurrentTask(); AssertCompletedWithStatus(task1, TaskStatus.RanToCompletion); AssertNotCompleted(task2, completionTask); // Server handles second message fake.CompleteCurrentTask(); AssertCompletedWithStatus(task2, TaskStatus.RanToCompletion); AssertNotCompleted(completionTask); // Server handles completion fake.CompleteCurrentTask(); AssertCompletedWithStatus(completionTask, TaskStatus.RanToCompletion); fake.AssertMessages("1", "2"); fake.AssertCompleted(); }
public void WritesAfterMessagesAreSent() { // Unlike most other tests, here we write a message, the server completes the // task, write another message, server completes etc. var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 5); // First message var task1 = writer.WriteAsync("1"); fake.CompleteCurrentTask(); AssertCompletedWithStatus(task1, TaskStatus.RanToCompletion); // Second message var task2 = writer.WriteAsync("2"); fake.CompleteCurrentTask(); AssertCompletedWithStatus(task2, TaskStatus.RanToCompletion); // Completion var completionTask = writer.WriteCompleteAsync(); fake.CompleteCurrentTask(); AssertCompletedWithStatus(completionTask, TaskStatus.RanToCompletion); fake.AssertMessages("1", "2"); fake.AssertCompleted(); }
public void FaultedWriteFailsPendingTasks() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 5); var task1 = writer.WriteAsync("1"); var task2 = writer.WriteAsync("2"); var task3 = writer.WriteAsync("3"); var completionTask = writer.WriteCompleteAsync(); AssertNotCompleted(task1, task2, task3, completionTask); // Server handles first message successfully fake.CompleteCurrentTask(); AssertCompletedWithStatus(task1, TaskStatus.RanToCompletion); AssertNotCompleted(task2, task3, completionTask); // Server fails second message. All pending tasks become faulted with the same exception. var exception = new Exception("Bang"); fake.FailCurrentTask(exception); foreach (var task in new[] { task2, task3, completionTask }) { AssertCompletedWithStatus(task, TaskStatus.Faulted); Assert.Same(exception, task.Exception.InnerExceptions[0]); } }
/// <summary> /// Construct the bidirectional streaming method for <c>StreamingRecognize</c>. /// </summary> /// <param name="service">The service containing this streaming method.</param> /// <param name="call">The underlying gRPC duplex streaming call.</param> /// <param name="writeBuffer">The <see cref="BufferedClientStreamWriter{StreamingRecognizeRequest}"/> /// instance associated with this streaming call.</param> public StreamingRecognizeStreamImpl( SpeechClientImpl service, AsyncDuplexStreamingCall <StreamingRecognizeRequest, StreamingRecognizeResponse> call, BufferedClientStreamWriter <StreamingRecognizeRequest> writeBuffer) { _service = service; GrpcCall = call; _writeBuffer = writeBuffer; }
/// <summary> /// Waits for a limited time for the writer to become non-full. /// </summary> private void WaitForSpace(BufferedClientStreamWriter <string> writer) { var stopwatch = Stopwatch.StartNew(); while (writer.BufferedWriteCount >= writer.Capacity && stopwatch.Elapsed < s_waitForSpaceTimeout) { Thread.Sleep(100); } Assert.True(writer.BufferedWriteCount < writer.Capacity, $"Count {writer.BufferedWriteCount} should be less than capacity {writer.Capacity}"); }
public void CompleteWithNoWrites() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 5); var completionTask = writer.WriteCompleteAsync(); fake.CompleteCurrentTask(); AssertCompletedWithStatus(completionTask, TaskStatus.RanToCompletion); fake.AssertMessages(); fake.AssertCompleted(); }
public void BehaviorAfterCompleteCalled() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 5); writer.WriteCompleteAsync(); // The (object) casts are because to make xUnit understand that the call itself should throw; // we don't return a failed task. Assert.Throws <InvalidOperationException>(() => (object)writer.WriteCompleteAsync()); Assert.Throws <InvalidOperationException>(() => (object)writer.WriteAsync("x")); Assert.Null(writer.TryWriteAsync("y")); }
/// <summary> /// Waits for up to half a second for the writer to become non-full. /// </summary> private void WaitForSpace(BufferedClientStreamWriter <string> writer) { for (int i = 0; i < 5; i++) { if (writer.BufferedWriteCount < writer.Capacity) { return; } Thread.Sleep(100); } // Give it one last chance, and fail if we're still full. Assert.True(writer.BufferedWriteCount < writer.Capacity); }
/// <summary> /// Performs bidirectional streaming speech recognition: receive results while /// sending audio. This method is only available via the gRPC API (not REST). /// </summary> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <param name="streamingSettings"> /// If not null, applies streaming overrides to this RPC call. /// </param> /// <returns> /// The client-server stream. /// </returns> public override StreamingRecognizeStream StreamingRecognize( CallSettings callSettings = null, BidirectionalStreamingSettings streamingSettings = null) { Modify_StreamingRecognizeRequestCallSettings(ref callSettings); BidirectionalStreamingSettings effectiveStreamingSettings = streamingSettings ?? _callStreamingRecognize.StreamingSettings; AsyncDuplexStreamingCall <StreamingRecognizeRequest, StreamingRecognizeResponse> call = _callStreamingRecognize.Call(callSettings); BufferedClientStreamWriter <StreamingRecognizeRequest> writeBuffer = new BufferedClientStreamWriter <StreamingRecognizeRequest>( call.RequestStream, effectiveStreamingSettings.BufferedClientWriterCapacity); return(new StreamingRecognizeStreamImpl(this, call, writeBuffer)); }
public async Task AtomicTaskCompletion() { const int testSize = 100; var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 1); var msgs = Enumerable.Range(0, testSize).Select(x => x.ToString()).ToArray(); foreach (var msg in msgs) { // This write can fail if task completion inside writer is not atomic. Task task = writer.WriteAsync(msg); fake.CompleteCurrentTask(); await task.ConfigureAwait(false); } fake.AssertMessages(msgs); }
public void CompletionUsesBufferSpace() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 2); writer.WriteAsync("1"); writer.WriteAsync("2"); // Try completion, should throw because queue is full. // The (object) cast is because to make xUnit understand that the call itself should throw; // we don't return a failed task. Assert.Throws <InvalidOperationException>(() => (object)writer.WriteCompleteAsync()); // Try completion, should return null because queue is full. Assert.Null(writer.TryWriteCompleteAsync()); fake.CompleteCurrentTask(); fake.CompleteCurrentTask(); writer.WriteCompleteAsync(); fake.CompleteCurrentTask(); fake.AssertCompleted(); }
public void TryWriteBeyondBuffer() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 2); var task1 = writer.WriteAsync("1"); var task2 = writer.WriteAsync("2"); var task3 = writer.TryWriteAsync("3"); Assert.Null(task3); // Couldn't write. fake.CompleteCurrentTask(); // Message 1 WaitForSpace(writer); // Now the buffer is smaller, we can write again. var task4 = writer.TryWriteAsync("4"); Assert.NotNull(task4); // Try to write completion, will fail as buffer is full. var completionTask1 = writer.TryWriteCompleteAsync(); Assert.Null(completionTask1); fake.CompleteCurrentTask(); // Message 2 WaitForSpace(writer); // Now the buffer is smaller, we can write completion. var completionTask2 = writer.TryWriteCompleteAsync(); Assert.NotNull(completionTask2); fake.CompleteCurrentTask(); // Message 4 fake.CompleteCurrentTask(); // Completion AssertCompletedWithStatus(task1, TaskStatus.RanToCompletion); AssertCompletedWithStatus(task2, TaskStatus.RanToCompletion); AssertCompletedWithStatus(task4, TaskStatus.RanToCompletion); AssertCompletedWithStatus(completionTask2, TaskStatus.RanToCompletion); fake.AssertMessages("1", "2", "4"); fake.AssertCompleted(); }
public void FaultedWriteFailsFutureTasks() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 5); var task1 = writer.WriteAsync("1"); // Server fails first message var exception = new Exception("Bang"); fake.FailCurrentTask(exception); // Subsequent calls to Write and Complete fail var task2 = writer.WriteAsync("2"); var task3 = writer.WriteAsync("3"); var completionTask = writer.WriteCompleteAsync(); foreach (var task in new[] { task1, task2, task3, completionTask }) { AssertCompletedWithStatus(task, TaskStatus.Faulted); Assert.Same(exception, task.Exception.InnerExceptions[0]); } }
public void WriteOptions() { var options1 = new WriteOptions(); var options2 = new WriteOptions(); var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 5); writer.WriteAsync("1"); writer.WriteAsync("2", options1); writer.WriteAsync("3"); writer.WriteAsync("4", options2); fake.CompleteCurrentTask(); fake.CompleteCurrentTask(); fake.CompleteCurrentTask(); fake.CompleteCurrentTask(); fake.AssertOptions(null, options1, options1, options2); // This should pick up options2 from the writer, not from the queue. writer.WriteAsync("5"); fake.CompleteCurrentTask(); fake.AssertOptions(null, options1, options1, options2, options2); }
public void WriteBeyondBuffer() { var fake = new FakeWriter(); var writer = new BufferedClientStreamWriter <string>(fake, 2); var task1 = writer.WriteAsync("1"); var task2 = writer.WriteAsync("2"); // The (object) cast is because to make xUnit understand that the call itself should throw; // we don't return a failed task. Assert.Throws <InvalidOperationException>(() => (object)writer.WriteAsync("3")); fake.CompleteCurrentTask(); // Message 1 WaitForSpace(writer); // Now the buffer is smaller, we can write again. var task4 = writer.WriteAsync("4"); // Completion fails, no space in buffer Assert.Throws <InvalidOperationException>(() => (object)writer.WriteCompleteAsync()); fake.CompleteCurrentTask(); // Message 2 WaitForSpace(writer); // Completion succeeds, there is now space in the buffer. var completionTask = writer.WriteCompleteAsync(); fake.CompleteCurrentTask(); // Message 4 fake.CompleteCurrentTask(); // Completion AssertCompletedWithStatus(task1, TaskStatus.RanToCompletion); AssertCompletedWithStatus(task2, TaskStatus.RanToCompletion); AssertCompletedWithStatus(task4, TaskStatus.RanToCompletion); AssertCompletedWithStatus(completionTask, TaskStatus.RanToCompletion); fake.AssertMessages("1", "2", "4"); fake.AssertCompleted(); }