public async Task CancelPendingFlushLostOfCancellationsNoDataLost()
{
var writeSize = 16;
var singleWriteStream = new SingleWriteStream();
MemoryStream = singleWriteStream;
Writer = new StreamPipeWriter(MemoryStream, minimumSegmentSize: writeSize);
for (var i = 0; i < 10; i++)
{
FlushResult flushResult = new FlushResult();
var expectedData = Encoding.ASCII.GetBytes(new string('a', writeSize));
var tcs = new TaskCompletionSource <int>(TaskCreationOptions.RunContinuationsAsynchronously);
var task = Task.Run(async() =>
{
try
{
// Create two Segments
// First one will succeed to write, other one will hang.
for (var j = 0; j < 2; j++)
{
Writer.Write(expectedData);
}
var flushTask = Writer.FlushAsync();
tcs.SetResult(0);
flushResult = await flushTask;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw ex;
}
});
await tcs.Task;
Writer.CancelPendingFlush();
await task;
Assert.True(flushResult.IsCanceled);
}
// Only half of the data was written because every other flush failed.
Assert.Equal(16 * 10, ReadWithoutFlush().Length);
// Start allowing all writes to make read succeed.
singleWriteStream.AllowAllWrites = true;
Assert.Equal(16 * 10 * 2, Read().Length);
}
public async Task CanAdvanceWithPartialConsumptionOfFirstSegment(int firstWriteLength)
{
Writer = new StreamPipeWriter(Stream, MinimumSegmentSize, new TestMemoryPool(maxBufferSize: 20000));
await Writer.WriteAsync(Encoding.ASCII.GetBytes("a"));
var memory = Writer.GetMemory(firstWriteLength);
Writer.Advance(firstWriteLength);
memory = Writer.GetMemory();
Writer.Advance(memory.Length);
await Writer.FlushAsync();
Assert.Equal(firstWriteLength + memory.Length + 1, Read().Length);
}
public async Task CanSerializeBodyRequestCorrectly()
{
var stream = new MemoryStream();
using (var streamPipeWriter = new StreamPipeWriter(stream))
{
TextAnalysis.WriteRequest(streamPipeWriter, "This is a body of text\n with a new line");
await streamPipeWriter.FlushAsync();
}
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
var text = new StreamReader(stream, Encoding.UTF8).ReadToEnd();
text.ShouldBe(@"{""documents"":[{""language"":""en"",""id"":""doc"",""text"":""This is a body of text\n with a new line""}]}");
}
public async Task <IReadOnlyCollection <string> > Suggest(string url, string title, string body, string[] skipTags)
{
var document = $"{title}\n{body}".Trim();
if (string.IsNullOrWhiteSpace(document))
{
return new string[] { }
}
;
var request = new HttpRequestMessage(HttpMethod.Post, "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/entities");
var bodyStream = new MemoryStream();
using (var streamPipeWriter = new StreamPipeWriter(bodyStream))
{
WriteRequest(streamPipeWriter, document);
await streamPipeWriter.FlushAsync();
}
bodyStream.Seek(0, SeekOrigin.Begin);
request.Content = new StreamContent(bodyStream)
{
Headers = { { "Content-Type", MediaTypeNames.Application.Json } }
};
var response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
throw new InvalidOperationException(response.ReasonPhrase + "\n" + await response.Content.ReadAsStringAsync());
return(new string[] { });
}
var responseDoc = await JsonDocument.ParseAsync(await response.Content.ReadAsStreamAsync());
var doc = responseDoc.RootElement.GetProperty("documents")
.EnumerateArray()
.First(d => d.GetProperty("id").GetString() == _singleDocId);
return(doc.GetProperty("entities")
.EnumerateArray()
.Select(entity => (name: entity.GetProperty("name").GetString(),
matchCount: entity.GetProperty("matches").EnumerateArray().Count()))
.OrderByDescending(k => k.matchCount)
.Select(k => k.name.ToLowerInvariant().Replace(" ", "-"))
.ToArray());
}
