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); }