public void CanRunWithoutIndividualAwait()
{
var stopWatch = new Stopwatch();
var queue = new MemoryQueue <string>(nameof(CanRunWithoutIndividualAwait));
queue.SetQueueItemAction(SlowItemAction, true);
queue.KeepQueueAliveTimeSpan = TimeSpan.Zero;
stopWatch.Start();
for (var i = 0; i < 20000; i++)
{
queue.AddMessage($"item {i}");
}
UT.Assert.IsTrue(queue.OnlyForUnitTest_HasAliveBackgroundWorker);
while (queue.OnlyForUnitTest_HasAliveBackgroundWorker)
{
Console.WriteLine($"LatestItemFetchedAfterActiveTimeSpan: {queue.LatestItemFetchedAfterActiveTimeSpan.TotalMilliseconds} milliseconds.");
Thread.Sleep(TimeSpan.FromMilliseconds(20));
}
stopWatch.Stop();
Console.WriteLine($"LatestItemFetchedAfterActiveTimeSpan: {queue.LatestItemFetchedAfterActiveTimeSpan.TotalMilliseconds} milliseconds.");
Console.WriteLine();
Console.WriteLine($"Total time: {stopWatch.Elapsed.TotalMilliseconds} milliseconds");
UT.Assert.AreEqual(TimeSpan.Zero, queue.LatestItemFetchedAfterActiveTimeSpan);
UT.Assert.IsTrue(stopWatch.ElapsedMilliseconds < 2000);
}
public void MemoryQueue_Enqueue_OneItem()
{
var queue = new MemoryQueue();
queue.Enqueue(new LogEntry());
Assert.AreEqual(1, queue.Count, "Expected one entry in the queue");
}
public void WorksThroughIQueue()
{
var memQueue = new MemoryQueue <long>();
var converter = new TypeConverter();
using (var queue = (IQueue <int>) new TransformationQueue <int, long>(memQueue, converter))
{
Assert.AreEqual(0, queue.Count);
Assert.IsTrue(queue.TryAdd(1, 10000, CancellationToken.None));
Assert.AreEqual(1, queue.Count);
Assert.AreEqual(queue.Count, memQueue.Count);
queue.AddForced(2);
Assert.AreEqual(2, queue.Count);
int peekItem = 0;
Assert.IsTrue(queue.TryPeek(out peekItem, 10000, CancellationToken.None));
Assert.AreEqual(1, peekItem);
int takeItem = 0;
Assert.IsTrue(queue.TryTake(out takeItem, 10000, CancellationToken.None));
Assert.AreEqual(1, takeItem);
Assert.AreEqual(1, queue.Count);
Assert.IsTrue(queue.TryTake(out takeItem, 10000, CancellationToken.None));
Assert.AreEqual(2, takeItem);
Assert.AreEqual(0, queue.Count);
Assert.IsFalse(queue.TryTake(out takeItem, 0, CancellationToken.None));
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(queue.Count, memQueue.Count);
Assert.AreEqual(2, Volatile.Read(ref converter.ConvertNum));
Assert.AreEqual(3, Volatile.Read(ref converter.ConvertBackNum));
}
}
public static void SequentialTest()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var m = new MemoryQueue();
int taskCount = 100;
ITask[] tasks = new ITask[taskCount];
PromiseTaskResultHandle <int>[] handles = new PromiseTaskResultHandle <int> [taskCount];
for (int i = 0; i < taskCount; i++)
{
var add = new AddTask(new (i, i + 1));
tasks[i] = add;
var handle = new PromiseTaskResultHandle <int>(add, redis, (o) => Console.WriteLine($"result is ready: {o}"));
add.BindPromise(handle.GetPromise());
m.Enqueue(add.Serialize());
handles[i] = handle;
}
var resolver = new RedisPromiseServer(redis);
// promises resolved in a sequential manner. like one worker is processing all of them
for (int i = 0; i < taskCount; i++)
{
var task = new DefaultTaskDeserializer().Deserialize((string)m.Dequeue());
task.Execute();
var res = task.SerializeResult();
// thanks to BindPromise each task's instance id is also id of its related promise. So we can directly resolve related promise by using it.
resolver.Resolve(task.GetInstanceIdentifier(), res);
}
Thread.Sleep(1000);
}
public void LoggerManager_PublishEntries()
{
var manager = new MockLogManager();
var filteredQueue = new MemoryQueue();
filteredQueue.Enqueue(new LogEntry
{
Title = "test",
EventId = 1,
Priority = 1,
Severity = TraceEventType.Error,
Message = "testing"
});
filteredQueue.Enqueue(new LogEntry
{
Title = "test",
EventId = 1,
Priority = 1,
Severity = TraceEventType.Error,
Message = "testing"
});
manager.FilteredQueue = filteredQueue;
manager.PublishFilteredEntries();
Assert.AreEqual(0, manager.FilteredQueue.Count, "Expected zero enteries in the filtered queue");
}
public void Should_be_able_to_perform_all_operations()
{
MemoryQueue queue = null;
ReceivedMessage receivedMessage = null;
var transportMessage = new TransportMessage {
CorrelationId = Guid.NewGuid().ToString()
};
var stream = new MemoryStream(Encoding.ASCII.GetBytes("contents"));
Assert.That(() => queue = new MemoryQueue(new Uri("memory://test-queue")), Throws.Nothing);
Assert.That(queue, Is.Not.Null);
Assert.That(queue.IsEmpty, Is.True);
Assert.That(() => queue.Enqueue(transportMessage, stream), Throws.Nothing);
Assert.That(queue.IsEmpty, Is.False);
Assert.That(() => receivedMessage = queue.GetMessage(), Throws.Nothing);
Assert.That(receivedMessage, Is.Not.Null);
Assert.That(Encoding.ASCII.GetString(receivedMessage.Stream.ToBytes()), Is.EqualTo("contents"));
Assert.That(queue.IsEmpty, Is.True);
Assert.That(() => queue.Release(receivedMessage.AcknowledgementToken), Throws.Nothing);
Assert.That(queue.IsEmpty, Is.False);
Assert.That(() => receivedMessage = queue.GetMessage(), Throws.Nothing);
Assert.That(receivedMessage, Is.Not.Null);
Assert.That(Encoding.ASCII.GetString(receivedMessage.Stream.ToBytes()), Is.EqualTo("contents"));
Assert.That(queue.IsEmpty, Is.True);
Assert.That(() => queue.Acknowledge(receivedMessage.AcknowledgementToken), Throws.Nothing);
Assert.That(queue.IsEmpty, Is.True);
}
public async void Test1()
{
var q = new MemoryQueue <String>();
Assert.True(q.IsEmpty);
Assert.Equal(0, q.Count);
q.Add("test");
q.Add("newlife", "stone");
Assert.False(q.IsEmpty);
Assert.Equal(3, q.Count);
var s1 = q.TakeOne();
Assert.Equal("test", s1);
var ss = q.Take(3).ToArray();
Assert.Equal(2, ss.Length);
ThreadPoolX.QueueUserWorkItem(() =>
{
Thread.Sleep(1100);
q.Add("delay");
});
var s2 = await q.TakeOneAsync(1500);
Assert.Equal("delay", s2);
}
} // InitOutputLog()
#endregion
#region InitQueue()
/// <summary>
/// Initialize a Memory Queue
/// </summary>
/// <remarks>
/// This function intializes a Memory Queue component.
/// </remarks>
/// <name>InitQueue</name>
/// <filename>WeatherLoggerMain.cs</filename>
/// <author>Bryan Bennett</author>
/// <created>July 13, 2006</created>
/// <param name="aQueueCfg">
/// The Memory Queue configuration
/// </param>
/// <param name="aQueue">
/// The Memory Queue component to initialize
/// </param>
private void InitQueue(XmlAppConfig.MemQueueCfg aQueueCfg,
ref MemoryQueue aQueue)
{
try {
aQueue = new MemoryQueue(aQueueCfg.Name, aQueueCfg.NumBuffers,
aQueueCfg.BufferSize);
if (aQueueCfg.OpenMethod.ToUpper().IndexOf("ATTACH") >= 0)
{
if (aQueue.OpenedFirst)
{
throw new Exception("The " + aQueueCfg.Name +
" MemoryQueue has not been created.");
} // if OpenedFirst
} // if OpenMethod == ATTACH
else if (aQueueCfg.OpenMethod.ToUpper().IndexOf("CREATE") >= 0)
{
if (!aQueue.OpenedFirst)
{
throw new Exception("The " + aQueueCfg.Name +
" MemoryQueue has already been created.");
} // if !OpenedFirst
} // else if OpenMethod == CREATE
} // try
catch (Exception exp) {
throw new Exception("Could not " + aQueueCfg.OpenMethod +
" the " + aQueueCfg.Name + " MemoryQueue.",
exp);
} // catch exp
} // InitQueue()
public async Task dequeue_on_empty_queue_should_return_default_item()
{
var sut = new MemoryQueue <object>();
var actual = await sut.DequeueAsync();
actual.Should().BeNull();
}
// ==========================
private void StableIsEmptyAndCountTest(bool ord, bool bcg)
{
const int ItemCount = 100000;
MemoryQueue <int> high = new MemoryQueue <int>();
MemoryQueue <int> low = new MemoryQueue <int>();
for (int i = 0; i < ItemCount + 1; i++)
{
low.Add(i);
}
using (var q = new LevelingQueue <int>(high, low, ord ? LevelingQueueAddingMode.PreserveOrder : LevelingQueueAddingMode.PreferLiveData, bcg))
{
Assert.AreEqual(ItemCount + 1, q.Count);
if (bcg && !ord)
{
q.Take();
}
else
{
Assert.AreEqual(0, q.Take());
}
int startTime = Environment.TickCount;
while (!low.IsEmpty && (Environment.TickCount - startTime) < 500)
{
Assert.AreEqual(ItemCount, q.Count);
Assert.IsFalse(q.IsEmpty);
}
}
}
public void BacgroundTransferingWorksNonOrdBcg()
{
MemoryQueue <int> high = new MemoryQueue <int>(10);
MemoryQueue <int> low = new MemoryQueue <int>(10);
high.Add(1);
while (low.TryAdd(low.Count + 2))
{
;
}
using (var inst = new LevelingQueue <int>(high, low, LevelingQueueAddingMode.PreferLiveData, true))
{
Assert.AreEqual(1, inst.Take());
TimingAssert.AreEqual(10000, 10, () => high.Count);
Assert.AreEqual(0, low.Count);
int item = 0;
int expected = 2;
while (inst.TryTake(out item))
{
Assert.AreEqual(expected++, item);
}
}
}
public async Task dequeue_on_empty_queue_should_return_default_item()
{
var sut = new MemoryQueue<object>();
var actual = await sut.DequeueAsync();
actual.Should().BeNull();
}
private static void EnqueueMemoryJob(Job job)
{
if (_memoryQueue is null)
{
_memoryQueue = new MemoryQueue();
}
Task.Run(() => _memoryQueue.Enqueue(job));
}
public void ShouldEnqueue()
{
MemoryQueue<MyTestObject> queue = new MemoryQueue<MyTestObject>();
queue.Enqueue(new MyTestObject());
Assert.AreEqual(1, queue.Count);
}
public static void CreatePromiseTest()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var m = new MemoryQueue();
int taskCount = 100;
ITask[] tasks = new ITask[taskCount];
PromiseTaskResultHandle <int>[] handles = new PromiseTaskResultHandle <int> [taskCount];
for (int i = 0; i < taskCount; i++)
{
var add = new AddTask(new (i, i + 1));
tasks[i] = add;
var client = RedisPromiseClientFactory.GetInstance(redis);
var promise = client.CreatePromise();
add.BindPromise(promise);
var handle = new PromiseTaskResultHandle <int>(add, promise, (o) => Console.WriteLine($"result is ready: {o}"));
//now promise will be ready to resolve
client.Listen(promise);
m.Enqueue(add.Serialize());
handles[i] = handle;
}
var resolver = new RedisPromiseServer(redis);
// this is simulating many workers are resolving promises. (executing tasks in this context)
Parallel.ForEach(handles, ((handle) =>
{
var task = new DefaultTaskDeserializer().Deserialize((string)m.Dequeue());
task.Execute();
var res = task.SerializeResult();
// thanks to BindPromise each task's instance id is also id of its related promise. So we can directly resolve related promise by using it.
resolver.Resolve(task.GetInstanceIdentifier(), res);
}));
for (int i = 0; i < taskCount; i++)
{
int correctResult = i + i + 1;
while (!handles[i].IsResolved())
{
// it might not come from redis yet
Thread.Sleep(10);
}
var calculatedResult = (int)handles[i].GetObjectResult();
if (correctResult != calculatedResult)
{
throw new Exception("wrong result");
}
}
Console.WriteLine("ParallelTest is Successful");
Thread.Sleep(1000);
}
public void MemoryQueue_Dequeue_NoItem()
{
var queue = new MemoryQueue();
Assert.AreEqual(0, queue.Count, "Expected zero Entries in the queue.");
var entry = queue.Dequeue();
Assert.IsNull(entry, "Dequeue did not return back null when it had zero entries.");
}
public async Task enqueue_should_put_item_on_queue()
{
var sut = new MemoryQueue<object>();
var expected = new object();
await sut.EnqueueAsync(expected);
var actual = await sut.DequeueAsync();
actual.Should().BeSameAs(expected);
}
public async Task dequeue_item_should_work()
{
var sut = new MemoryQueue <object>();
var expected = new object();
await sut.EnqueueAsync(expected);
var actual = await sut.DequeueAsync();
actual.Should().BeSameAs(expected);
}
private static IQueue <long> CreateQueue1(string dir)
{
DiskQueue <int> disk = new DiskQueue <int>(dir, new NonPersistentDiskQueueSegmentFactory <int>(10000, "prefix", new ItemSerializer()), 100, true);
MemoryQueue <int> preDisk = new MemoryQueue <int>(5000);
LevelingQueue <int> diskWrap = new LevelingQueue <int>(preDisk, disk, LevelingQueueAddingMode.PreserveOrder, true);
TransformationQueue <long, int> transform = new TransformationQueue <long, int>(diskWrap, new TypeConverter());
MemoryQueue <long> topMem = new MemoryQueue <long>(1000);
LevelingQueue <long> topQ = new LevelingQueue <long>(topMem, transform, LevelingQueueAddingMode.PreserveOrder, true);
return(topQ);
}
public void MemoryQueue_Dequeue_OneItem()
{
var expected = new LogEntry();
var queue = new MemoryQueue();
queue.Enqueue(expected);
var actual = queue.Dequeue();
Assert.AreEqual(0, queue.Count, "Expected zero entries in the queue");
Assert.AreEqual(expected.Id, actual.Id, "The Id of the enqueued item did not match the Id of the dequeued item.");
Assert.AreEqual(expected, actual, "A different object was returned from dequeue than what was inserted.");
}
protected virtual async Task LoadConsumer()
{
int idleCount = 0;
await Task.Delay(1000);
while (_ConsumerStatus != ConsumerStatus.DISPOSE)
{
try
{
while (_ConsumerStatus == ConsumerStatus.OFFLINE)
{
await Task.Delay(1000);
}
;
var objects = GetObjectsFromQueue(MaxMemoryQueueObjects - MemoryQueue.Count);
if (objects.NullOrEmpty())
{
idleCount++;
if (_ConsumerStatus == ConsumerStatus.ONLINE_IDLE)
{
var waitingTime = idleCount * SCHEDULE_BASE_IDLE_TIME;
if (waitingTime >= SCHEDULE_MAX_IDLE_TIME)
{
waitingTime = SCHEDULE_BASE_IDLE_TIME;
}
await Task.Delay(waitingTime);
}
else
{
if (_ConsumerStatus == ConsumerStatus.ONLINE && idleCount >= 25)
{
_ConsumerStatus = ConsumerStatus.ONLINE_IDLE;
}
}
}
else
{
idleCount = 0;
_ConsumerStatus = ConsumerStatus.ONLINE;
MemoryQueue.EnqueueRange(objects);
}
}
catch (Exception ex)
{
Log.Error($"Consumer from ThreadGroup '{this.ThreadGroup}' and ThreadGuid:'{this.ThreadGuid} could not get objects from queue.", exception: ex);
_ConsumerStatus = ConsumerStatus.ONLINE_IDLE;
}
}
}
public void Should_be_able_to_create_new_routes()
{
var queue = new MemoryQueue(new Uri("memory://."));
var route = new MessageRoute(queue);
var routes = new MessageRouteCollection();
route.AddSpecification(new RegexMessageRouteSpecification("simple"));
routes.Add(route);
Assert.AreSame(queue, routes.FindAll(new SimpleCommand())[0].Queue);
}
public void ShouldDequeue()
{
MemoryQueue<MyTestObject> queue = new MemoryQueue<MyTestObject>();
queue.Enqueue(new MyTestObject());
Assert.AreEqual(1, queue.Count);
object myObject = queue.Dequeue();
Assert.IsInstanceOf(typeof(MyTestObject), myObject);
}
public void ShouldClear()
{
int expected = 0;
MemoryQueue<MyTestObject> queue = new MemoryQueue<MyTestObject>();
queue.Enqueue(new MyTestObject());
Assert.AreEqual(1, queue.Count);
queue.Clear();
Assert.AreEqual(expected, queue.Count);
}
public void MemoryQueue_Peek_ThreeItems()
{
var expected = new LogEntry();
var queue = new MemoryQueue();
queue.Enqueue(expected);
queue.Enqueue(new LogEntry());
queue.Enqueue(new LogEntry());
Assert.AreEqual(3, queue.Count, "Expected three Entries in the queue.");
var actual = queue.Peek();
Assert.AreEqual(expected.Id, actual.Id, "The Id of the enqueued item did not match the Id of the Peeked item.");
Assert.AreEqual(expected, actual, "A different object was returned from Peek than what was inserted.");
}
public ActionResult <SortJob> EnqueueJob(int[] values)
{
// TODO: Should enqueue a job to be processed in the background.
var pendingJob = new SortJob(
id: Guid.NewGuid(),
status: SortJobStatus.Pending,
duration: null,
input: values,
output: null);
MemoryQueue.InsertToQueue(pendingJob);
return(Ok(pendingJob));
}
public void MessageCountIncreasedWhenAddingToQueue()
{
var queue = new MemoryQueue <string>("queueName");
var expectedCount = 5;
for (var i = 0; i < expectedCount; i++)
{
queue.AddMessage($"item {i}");
}
var count = queue.GetApproximateMessageCountAsync().Result;
UT.Assert.AreEqual(expectedCount, count);
}
public static void Boot()
{
//should consider this
new CreateDatabaseIfNotExists <TestDbContext>().InitializeDatabase(new TestDbContext());
//if dont want manual regist = code
//can use reflection to load dll from folder Bin eg:
MemoryMessageBuss.AutoRegisterExecutingAssembly();
//manual register command handle and event handle
//EventHandleRegister();
//CommandHandleRegister();
MemoryQueue.Boot();
}
public void Log(List <AbstractLogInfo> logInfo)
{
#if DEBUG
Console.WriteLine("===================================START=======================================");
Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " " + logInfo.First().GetType().Name);
logInfo.ForEach(Console.WriteLine);
Console.WriteLine("=================================== END =======================================");
#endif
if (logInfo == null || logInfo.Count == 0)
{
return;
}
// You can rerite rewrite this logic to implement your log persistence logic.
MemoryQueue.BatchEnqueue(logInfo);
}
public void EntryEnqueuedRaiseEvent()
{
bool eventRaised = false;
var expected = new LogEntry();
var queue = new MemoryQueue();
queue.EntryEnqueued +=
delegate(object sender, EntryEnqueuedEventArgs e)
{
Assert.AreEqual(1, queue.Count, "Expected one entry in the queue");
Assert.AreEqual(expected, e.Entry, "Expected correct object should be enqueued");
eventRaised = true;
};
queue.Enqueue(expected);
Assert.IsTrue(eventRaised, "Event was not raised");
}
public void ShouldDequeueWithTimeSpanTimeout()
{
int expected = 1000;
MemoryQueue<MyTestObject> queue = new MemoryQueue<MyTestObject>();
TimeSpan timespan = new TimeSpan(0, 0, 0, 0, expected);
queue.Dequeue(expected);
int actual = Convert.ToInt32(timespan.TotalMilliseconds);
// We divide to ensure that a millisecond or so won't make a difference to our test result.
expected = expected / 100;
actual = actual / 100;
Assert.AreEqual(expected, actual);
}
public void AddTakeMultithreadTest()
{
const int ItemsCount = 10000;
using (var queue = new MemoryQueue <int>())
using (var barrier = new Barrier(2))
{
ConcurrentBag <int> bag = new ConcurrentBag <int>();
var task1 = Task.Run(() =>
{
barrier.SignalAndWait();
Parallel.For(0, ItemsCount, val =>
{
queue.Add(val);
Thread.SpinWait(val % 100);
});
});
var task2 = Task.Run(() =>
{
barrier.SignalAndWait();
Parallel.For(0, 10000, val =>
{
int res = 0;
if (!queue.TryTake(out res, 10000))
{
Assert.Fail("Value was expected in MemoryQueue");
}
bag.Add(res);
Thread.SpinWait((val + 37) % 100);
});
});
Task.WaitAll(task1, task2);
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(ItemsCount, bag.Count);
var array = bag.ToArray();
Array.Sort(array);
for (int i = 0; i < array.Length; i++)
{
Assert.AreEqual(i, array[i], "i != array[i]");
}
}
}
public void ParallelUnitTest()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var m = new MemoryQueue();
RedisPromiseClient promiseClient = new RedisPromiseClient(redis);
int taskCount = 100;
ITask[] tasks = new ITask[taskCount];
PromiseTaskResultHandle <int>[] handles = new PromiseTaskResultHandle <int> [taskCount];
for (int i = 0; i < taskCount; i++)
{
var add = new AddTask(new (i, i + 1));
tasks[i] = add;
var handle = new PromiseTaskResultHandle <int>(add, redis);
handle.Listen(promiseClient);
m.Enqueue(add.Serialize());
handles[i] = handle;
}
var resolver = new RedisPromiseServer(redis);
// this is simulating many workers are resolving promises. (executing tasks in this context)
Parallel.ForEach(handles, ((handle) =>
{
var task = new DefaultTaskDeserializer().Deserialize((string)m.Dequeue());
task.Execute();
var res = task.SerializeResult();
// thanks to BindPromise each task's instance id is also id of its related promise. So we can directly resolve related promise by using it.
resolver.Resolve(task.GetInstanceIdentifier(), res);
}));
for (int i = 0; i < taskCount; i++)
{
int correctResult = i + i + 1;
while (!handles[i].IsResolved())
{
// it might not come from redis yet
Thread.Sleep(10);
}
var calculatedResult = (int)handles[i].GetObjectResult();
Assert.Equal(correctResult, calculatedResult);
}
}
static void Main(string[] args)
{
var docs = new MemoryRepository <Document>();
var repos = new MemoryRepository <Repository>();
var orgs = new MemoryRepository <Organization>();
var users = new MemoryRepository <User>();
var newOrg = new Organization()
{
Created = DateTime.UtcNow,
Updated = DateTime.UtcNow,
Name = "evuru",
};
orgs.Add(newOrg);
var metadata = new AzureDevOpsMetadata
{
PersonalAccessToken = "",
};
var newRepo = new Repository()
{
Name = newOrg.Name,
OrganizationId = newOrg.Id,
SCM = SupportedSystems.GitHub,
CustomRepositoryInformation = JsonConvert.SerializeObject(metadata)
};
repos.Add(newRepo);
var db = new MemoryDataContext(docs, orgs, repos, users);
var queue = new MemoryQueue <RepositoryUpdatedMessage>();
while (true)
{
queue.PushMessage(new RepositoryUpdatedMessage(newRepo.Id));
var scraper = new Scraper(db);
scraper.ScrapeRepository(queue.PopMessage()).Wait();
Display(db);
Thread.Sleep(30000);
}
}
public void AddTakeSequentialTest()
{
const int ItemsCount = 10000;
using (var queue = new MemoryQueue <int>())
using (var barrier = new Barrier(2))
{
List <int> bag = new List <int>();
var task1 = Task.Run(() =>
{
barrier.SignalAndWait();
for (int val = 0; val < ItemsCount; val++)
{
queue.Add(val);
Thread.SpinWait(val % 100);
}
});
var task2 = Task.Run(() =>
{
barrier.SignalAndWait();
for (int val = 0; val < ItemsCount; val++)
{
int res = 0;
if (!queue.TryTake(out res, 10000))
{
Assert.Fail("Value was expected in MemoryQueue");
}
bag.Add(res);
Thread.SpinWait((val + 37) % 100);
}
});
Task.WaitAll(task1, task2);
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(ItemsCount, bag.Count);
for (int i = 0; i < bag.Count; i++)
{
Assert.AreEqual(i, bag[i], "i != bag[i]");
}
}
}
public void ShouldDequeueWithIntTimeout()
{
int expected = 1000;
MemoryQueue<MyTestObject> queue = new MemoryQueue<MyTestObject>();
DateTime startDateTime = DateTime.UtcNow;
queue.Dequeue(expected);
DateTime endDateTime = DateTime.UtcNow;
TimeSpan timeSpace = endDateTime - startDateTime;
int actual = Convert.ToInt32(timeSpace.TotalMilliseconds);
// We divide to ensure that a millisecond or so won't make a difference to our test result.
expected = expected / 100;
actual = actual / 100;
Assert.AreEqual(expected, actual);
}
public void LoggerManager_FilterEntries_ThreeEntries()
{
var manager = new MockLogManager();
manager.ExecutePublishFilter = false;
var unfilteredQueue = new MemoryQueue();
unfilteredQueue.Enqueue(new LogEntry
{
Title = "test",
EventId = 1,
Priority = 1,
Severity = TraceEventType.Error,
Message = "testing"
});
unfilteredQueue.Enqueue(new LogEntry
{
Title = "test",
EventId = 1,
Priority = 1,
Severity = TraceEventType.Error,
Message = "testing"
});
unfilteredQueue.Enqueue(new LogEntry
{
Title = "test",
EventId = 1,
Priority = 1,
Severity = TraceEventType.Error,
Message = "testing"
});
manager.UnfilteredQueue = unfilteredQueue;
var filteredQueue = new MemoryQueue();
manager.FilteredQueue = filteredQueue;
manager.Initialize(new Uri("http://test"));
manager.ExecuteFilter();
Assert.IsTrue(manager.FilterCalled, "Filter was not called.");
Assert.AreEqual(3, manager.FilteredQueue.Count, "Filters were not executed correctly.");
}
public void ShouldReleaseWaitingThreads()
{
Thread thread = new Thread(new ThreadStart(ThreadMethod));
thread.IsBackground = true;
thread.Start();
MemoryQueue<MyTestObject> queue = new MemoryQueue<MyTestObject>();
queue.ReleaseWaitingThreads();
_resetEvent.WaitOne();
}
public void ShouldPeek()
{
MemoryQueue<MyTestObject> queue = new MemoryQueue<MyTestObject>();
MyTestObject actualObj = new MyTestObject();
queue.Enqueue(actualObj);
Assert.AreEqual(1, queue.Count);
MyTestObject testObj = queue.Peek();
Assert.AreEqual(1, queue.Count);
Assert.AreEqual(actualObj.SomeValue, testObj.SomeValue);
}
