Exemplo n.º 1
0
        public void ZeroLimitMeansUnlimitedSize()
        {
            var q = new LimitedSizeQueue <int>(0);

            foreach (var item in Enumerable.Range(1, 1000))
            {
                Assert.IsTrue(q.TryEnqueue(item));
            }

            q.Clear();
            Assert.AreEqual(0, q.Count);
            Assert.AreEqual(0, q.Limit);
        }
Exemplo n.º 2
0
        public TimeTravelBox(Rectangle rectangle, int wrapDelay) : base(rectangle)
        {
            var path = "sprites/Objects/BoxShadow/Box";

            shadow = new AnimatedSprite(animator, rectangle, 10,
                                        new List <Image>
            {
                new Bitmap(path + ".png"),
                new Bitmap(path + "-2.png"),
                new Bitmap(path + "-3.png"),
                new Bitmap(path + "-2.png")
            },
                                        GetSprite().ZIndex - 1);
            pastPosition   = new LimitedSizeQueue <PointF>(wrapDelay);
            OnStateUpdate += TimeTravelBoxOnStateUpdate;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SimpleLockThreadPool" /> class.
        /// </summary>
        /// <param name="concurrencyLevel">The concurrency level.</param>
        /// <param name="flowExecutionContext">if set to <c>true</c>, the execution context is flown.</param>
        /// <param name="limit">High watermark limit for the work item queue size.</param>
        public SimpleLockThreadPool(int concurrencyLevel, bool flowExecutionContext, int limit = 0)
        {
            if (concurrencyLevel <= 0)
            {
                throw new ArgumentOutOfRangeException("concurrencyLevel");
            }

            m_concurrencyLevel     = concurrencyLevel;
            m_flowExecutionContext = flowExecutionContext;
            m_queue = new LimitedSizeQueue <WorkItem>(limit);

#if !XAMARIN
            // If suppressing flow, we need to demand permissions.
            if (!flowExecutionContext)
            {
                new SecurityPermission(SecurityPermissionFlag.Infrastructure).Demand();
            }
#endif
        }
Exemplo n.º 4
0
        public void LimitedSizeQueueCanClearItems()
        {
            var q = new LimitedSizeQueue <int>(3);

            Assert.IsTrue(q.TryEnqueue(1));
            Assert.IsTrue(q.TryEnqueue(2));
            Assert.IsTrue(q.TryEnqueue(3));
            Assert.IsFalse(q.TryEnqueue(4));

            Assert.AreEqual(3, q.Count);
            Assert.AreEqual(3, q.Limit);

            q.Clear();
            Assert.AreEqual(0, q.Count);
            Assert.AreEqual(3, q.Limit);

            var items = string.Join(", ", q.Select(i => i.ToString()).ToArray());

            Assert.AreEqual(string.Empty, items);
        }
Exemplo n.º 5
0
        public void LimitedSizeQueueLimitsTheSizeOfTheInternalQueue()
        {
            var q = new LimitedSizeQueue <int>(3);

            Assert.AreEqual(0, q.Count);
            Assert.AreEqual(3, q.Limit);
            Assert.IsFalse(q.TryPeek(out _));
            Assert.IsFalse(q.TryDequeue(out _));

            Assert.IsTrue(q.TryEnqueue(1));
            Assert.IsTrue(q.TryEnqueue(2));
            Assert.IsTrue(q.TryEnqueue(3));
            Assert.IsFalse(q.TryEnqueue(4));
            Assert.IsFalse(q.TryEnqueue(5));

            var items = string.Join(", ", q.Select(i => i.ToString()).ToArray());

            Assert.AreEqual("1, 2, 3", items);

            Assert.IsTrue(q.TryDequeue(out var item));
            Assert.AreEqual(1, item);

            Assert.IsTrue(q.TryEnqueue(6));
            Assert.IsFalse(q.TryEnqueue(7));

            Assert.IsTrue(q.TryDequeue(out item));
            Assert.AreEqual(2, item);

            Assert.IsTrue(q.TryDequeue(out item));
            Assert.AreEqual(3, item);

            Assert.IsTrue(q.TryPeek(out item));
            Assert.AreEqual(6, item);

            Assert.IsTrue(q.TryDequeue(out item));
            Assert.AreEqual(6, item);

            Assert.IsFalse(q.TryPeek(out _));
            Assert.IsFalse(q.TryDequeue(out _));
        }