public async Task ShouldUseBuffer()
{
var bu = new TestBuffer();
_publisher.SetBuffer(bu);
_publisher.Start();
SetupNormalQueue();
const int msgCount = 10;
for (int i = 0; i < msgCount; i++)
{
var expected = i.ToString();
await _publisher.ProduceAsync(expected);
var result = ReadFromQueue();
Assert.That(result, Is.EqualTo(string.Empty));
}
Assert.That(bu.Count, Is.EqualTo(msgCount));
bu.Gate.Set();
while (bu.Count > 0)
{
Thread.Sleep(1);
}
for (int i = 0; i < msgCount; i++)
{
var expected = i.ToString();
var result = ReadFromQueue();
Assert.That(result, Is.EqualTo(expected));
}
}
public bool TryReadAndReturnTrueIfDone(TestBuffer buf)
{
_log($" Try reading of {this}: ");
try
{
var x = buf.Read(this);
_log("OK\n");
if (x != _counter)
{
throw new AssertionFailedException(
$@"|Run {_run}, cursorNr {_cursorNr}, counter {_counter}: got unexpected {x}
| Buf: {buf.Inspect()}
| Cursors: {buf.UnderlyingCursors.Cursors.Aggregate(" ", (s, cursor) => s + cursor + "\n ")}
|Log: {_sb}
");
}
_counter++;
return(_counter == _counterLimit);
}
catch (NothingToReadException)
{
_log("FAILED\n");
return(false); // ok, we currently can't read, try again later
}
}
public void ShouldRethrowPublishingException()
{
var bu = new TestBuffer();
bu.Gate.Set();
SetupNormalQueue();
var pubStrategy = Substitute.For <IRabbitMqPublishStrategy>();
_publisher.SetBuffer(bu);
_publisher.SetPublishStrategy(pubStrategy);
_publisher.PublishSynchronously();
_publisher.Start();
pubStrategy.When(m => m.Publish(Arg.Any <RabbitMqSubscriptionSettings>(), Arg.Any <IModel>(), Arg.Any <RawMessage>())).Throw <InvalidOperationException>();
Assert.Throws <RabbitMqBrokerException>(() => _publisher.ProduceAsync(string.Empty).Wait());
}
public void EmptyFile_Read_Succeeds()
{
using (var fs = CreateFileStream(GetTestFilePath(), FileMode.Create))
{
// use a recognizable pattern
var buffer = (byte[])TestBuffer.Clone();
Assert.Equal(0, fs.Read(Span <byte> .Empty));
Assert.Equal(0, fs.Read(new Span <byte>(buffer, 0, 1)));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, fs.Read(new Span <byte>(buffer, 0, buffer.Length)));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, fs.Read(new Span <byte>(buffer, buffer.Length - 1, 1)));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, fs.Read(new Span <byte>(buffer, buffer.Length / 2, buffer.Length - buffer.Length / 2)));
Assert.Equal(TestBuffer, buffer);
}
}
public async Task EmptyFile_ReadAsync_Succeeds()
{
using (var fs = CreateFileStream(GetTestFilePath(), FileMode.Create))
{
// use a recognizable pattern
var buffer = (byte[])TestBuffer.Clone();
Assert.Equal(0, await fs.ReadAsync(Memory <byte> .Empty));
Assert.Equal(0, await fs.ReadAsync(new Memory <byte>(buffer, 0, 1)));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, await fs.ReadAsync(new Memory <byte>(buffer, 0, buffer.Length)));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, await fs.ReadAsync(new Memory <byte>(buffer, buffer.Length - 1, 1)));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, await fs.ReadAsync(new Memory <byte>(buffer, buffer.Length / 2, buffer.Length - buffer.Length / 2)));
Assert.Equal(TestBuffer, buffer);
}
}
public void EmptyFileReadsSucceed()
{
using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create))
{
byte[] buffer = new byte[TestBuffer.Length];
// use a recognizable pattern
TestBuffer.CopyTo(buffer, 0);
Assert.Equal(0, fs.Read(buffer, 0, 1));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, fs.Read(buffer, 0, buffer.Length));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, fs.Read(buffer, buffer.Length - 1, 1));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, fs.Read(buffer, buffer.Length / 2, buffer.Length - buffer.Length / 2));
Assert.Equal(TestBuffer, buffer);
}
}
public async Task EmptyFileReadAsyncSucceedSynchronously()
{
using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create))
{
byte[] buffer = new byte[TestBuffer.Length];
// use a recognizable pattern
TestBuffer.CopyTo(buffer, 0);
// note that these do not succeed synchronously even though they do nothing.
Assert.Equal(0, await ReadAsync(fs, buffer, 0, 1));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, await ReadAsync(fs, buffer, 0, buffer.Length));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, await ReadAsync(fs, buffer, buffer.Length - 1, 1));
Assert.Equal(TestBuffer, buffer);
Assert.Equal(0, await ReadAsync(fs, buffer, buffer.Length / 2, buffer.Length - buffer.Length / 2));
Assert.Equal(TestBuffer, buffer);
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
TestCommand cmd = _historyStack.Spwaner <TestCommand>();
TestBuffer buffer = new TestBuffer();
buffer.id = i;
cmd.InsertBuffer(buffer);
_historyStack.Do(cmd);
i++;
}
if (Input.GetKeyDown(KeyCode.A))
{
_historyStack.Undo();
}
if (Input.GetKeyDown(KeyCode.B))
{
_historyStack.Redo();
}
}
public void A_RetainingMultiReaderBufferSpec_should_pass_the_stress_test()
{
// create 100 buffers with an initialSize of 1 and a maxSize of 1 to 64,
// for each one attach 1 to 8 cursors and randomly try reading and writing to the buffer;
// in total 200 elements need to be written to the buffer and read in the correct order by each cursor
var MAXSIZEBIT_LIMIT = 6; // 2 ^ (this number)
var COUNTER_LIMIT = 200;
var LOG = false;
var sb = new StringBuilder();
var log = new Action <string>(s =>
{
if (LOG)
{
sb.Append(s);
}
});
var random = new Random();
for (var bit = 1; bit <= MAXSIZEBIT_LIMIT; bit++)
{
for (var n = 1; n <= 2; n++)
{
var counter = 1;
var activeCoursors =
Enumerable.Range(0, random.Next(8) + 1)
.Select(i => new StressTestCursor(i, 1 << bit, log, COUNTER_LIMIT, sb))
.ToList();
var stillWriting = 2;// give writing a slight bias, so as to somewhat "stretch" the buffer
var buf = new TestBuffer(1, 1 << bit, new SimpleCursors(activeCoursors));
sb.Clear();
while (activeCoursors.Count != 0)
{
log($"Buf: {buf.Inspect()}\n");
var activeCursorCount = activeCoursors.Count;
var index = random.Next(activeCursorCount + stillWriting);
if (index >= activeCursorCount)
{
log($" Writing {counter}: ");
if (buf.Write(counter))
{
log("OK\n");
counter++;
}
else
{
log("FAILED\n");
if (counter == COUNTER_LIMIT)
{
stillWriting = 0;
}
}
}
else
{
var cursor = activeCoursors[index];
if (cursor.TryReadAndReturnTrueIfDone(buf))
{
activeCoursors = activeCoursors.Where(c => c != cursor).ToList();
}
}
}
}
}
}
public void TestByteBuffer(TestBuffer tb)
{
}
public void TestByteBuffer(TestBuffer tb)
{
}
