public void Can_append_record()
{
var queueStream = new SingleFileQueueStream(_stream);
using(var stream = new MemoryStream()) {
stream.Write(BitConverter.GetBytes(10));
stream.Seek(0, SeekOrigin.Begin);
queueStream.AppendRecord(stream, stream.Length);
AssertRecord(10, 0, false);
Assert.AreEqual(1, queueStream.UnreadCount);
}
}
public void End_to_end_test()
{
var file = Path.GetTempFileName();
try {
var queueStream = new SingleFileQueueStream(file);
var serializer = new XDocQueueItemSerializer();
using(var queue = new TransactionalQueue<XDoc>(queueStream, serializer)) {
var doc = new XDoc("foo");
queue.Enqueue(doc);
var v = queue.Dequeue();
Assert.AreEqual(doc, v.Value);
Assert.IsTrue(queue.CommitDequeue(v.Id));
}
} finally {
File.Delete(file);
}
}
public void Can_append_record_to_existing_queue()
{
AppendRecord(1, false);
AppendRecord(2, true);
var queueStream = new SingleFileQueueStream(_stream);
using(var stream = new MemoryStream()) {
stream.Write(BitConverter.GetBytes(10));
stream.Seek(0, SeekOrigin.Begin);
var position = _stream.Length;
queueStream.AppendRecord(stream, stream.Length);
AssertRecord(10, position, false);
Assert.AreEqual(2, queueStream.UnreadCount);
}
}
public void Trying_to_open_two_instances_on_same_path_throws()
{
var path = Path.GetTempFileName();
var instance1 = new SingleFileQueueStream(path);
try {
var instance2 = new SingleFileQueueStream(path);
} catch(IOException) {
return;
}
Assert.Fail("didn't throw IOException");
}
public void Mix_of_deleted_and_undeleted_initializes_Count_to_undeleted_only()
{
AppendRecord(1, false);
AppendRecord(2, true);
AppendRecord(3, false);
AppendRecord(4, true);
AppendRecord(5, false);
_log.DebugFormat("stream length: {0}", _stream.Length);
var queueStream = new SingleFileQueueStream(_stream);
Assert.AreEqual(3, queueStream.UnreadCount);
}
public void Deleting_last_record_truncates_file()
{
AppendRecord(1, false);
AppendRecord(2, true);
AppendRecord(3, false);
var queueStream = new SingleFileQueueStream(_stream);
var handle1 = queueStream.ReadNextRecord().Handle;
var handle2 = queueStream.ReadNextRecord().Handle;
queueStream.DeleteRecord(handle1);
queueStream.DeleteRecord(handle2);
Assert.AreEqual(0, _stream.Length);
}
public void Creates_path_if_not_exists()
{
var path = Path.Combine(Path.Combine(Path.GetTempPath(), StringUtil.CreateAlphaNumericKey(6)), "queue.bin");
var instance1 = new SingleFileQueueStream(path);
Assert.IsTrue(File.Exists(path));
}
public void Count_on_empty_stream_returns_0()
{
var queueStream = new SingleFileQueueStream(_stream);
Assert.AreEqual(0, queueStream.UnreadCount);
}
public void Corrupt_record_is_ignored_at_initialization()
{
var v1 = "asdsdasdasdasdasd";
var v2 = "asdasdsadasdwwdsdw";
AppendRecord(v1, false);
for(byte i = 0; i < 6; i++) {
_stream.WriteByte(i);
}
AppendRecord(v2, false);
var queueStream = new SingleFileQueueStream(_stream);
Assert.AreEqual(2,queueStream.UnreadCount);
Assert.AreEqual(v1, GetStringValue(queueStream.ReadNextRecord().Stream));
Assert.AreEqual(v2, GetStringValue(queueStream.ReadNextRecord().Stream));
}
public void Corrupt_record_does_not_stop_further_appending_dequeueing()
{
var v1 = "asdsdasdasdasdasd";
var v2 = "asdasdsadasdwwdsdw";
AppendRecord(v1, false);
for(byte i = 0; i < 6; i++) {
_stream.WriteByte(i);
}
var position = _stream.Position;
var queueStream = new SingleFileQueueStream(_stream);
Assert.AreEqual(1, queueStream.UnreadCount);
using(var stream = new MemoryStream()) {
stream.Write(Encoding.UTF8.GetBytes(v2));
stream.Seek(0, SeekOrigin.Begin);
queueStream.AppendRecord(stream, stream.Length);
AssertRecord(v2, position, false);
Assert.AreEqual(2, queueStream.UnreadCount);
}
Assert.AreEqual(v1, GetStringValue(queueStream.ReadNextRecord().Stream));
Assert.AreEqual(v2, GetStringValue(queueStream.ReadNextRecord().Stream));
}
public void Can_read_consecutive_records()
{
AppendRecord(1, false);
AppendRecord(2, true);
AppendRecord(3, false);
var queueStream = new SingleFileQueueStream(_stream);
Assert.AreEqual(1, GetIntValue(queueStream.ReadNextRecord().Stream));
Assert.AreEqual(3, GetIntValue(queueStream.ReadNextRecord().Stream));
Assert.AreEqual(0, queueStream.UnreadCount);
}
public void Can_delete_record()
{
AppendRecord(1, false);
AppendRecord(2, false);
var queueStream = new SingleFileQueueStream(_stream);
var handle = queueStream.ReadNextRecord().Handle;
queueStream.DeleteRecord(handle);
AssertRecord(1, 0, true);
}
public void Can_append_record_to_truncated_file()
{
AppendRecord(1, false);
var queueStream = new SingleFileQueueStream(_stream);
var handle = queueStream.ReadNextRecord().Handle;
queueStream.DeleteRecord(handle);
using(var stream = new MemoryStream()) {
stream.Write(BitConverter.GetBytes(10));
stream.Seek(0, SeekOrigin.Begin);
queueStream.AppendRecord(stream, stream.Length);
AssertRecord(10, 0, false);
Assert.AreEqual(1, queueStream.UnreadCount);
}
}
public void Load_test_mixed_put_peek_take_with_single_file_queue()
{
var file = Path.GetTempFileName();
var serializer = new XDocQueueItemSerializer();
Func<TransactionalQueue<XDoc>> ctor = () => {
var queueStream = new SingleFileQueueStream(file);
var q = new TransactionalQueue<XDoc>(queueStream, serializer) { DefaultCommitTimeout = TimeSpan.FromSeconds(5) };
return q;
};
try {
Load_test(ctor);
} finally {
File.Delete(file);
}
}
public void Perf_test_single_thread_put_peek_and_take_with_single_file_queue()
{
var file = Path.GetTempFileName();
try {
var queueStream = new SingleFileQueueStream(file);
var serializer = new XDocQueueItemSerializer();
using(ITransactionalQueue<XDoc> queue = new TransactionalQueue<XDoc>(queueStream, serializer)) {
Perf_test_single_thread_put_peek_and_take(queue);
}
} finally {
_log.DebugFormat("wiping xdoc queue");
File.Delete(file);
}
}
public void Perf_test_single_thread_put_peek_and_take_with_memorystream_queue()
{
using(var stream = new MemoryStream()) {
var queueStream = new SingleFileQueueStream(stream);
var serializer = new XDocQueueItemSerializer();
using(ITransactionalQueue<XDoc> queue = new TransactionalQueue<XDoc>(queueStream, serializer)) {
Perf_test_single_thread_put_peek_and_take(queue);
}
}
}
