예제 #1
0
        public void Deque_ConstructedWithCollection_RemembersCollection()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5 });

            Assert.AreEqual(5, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 1, 2, 3, 4, 5 }), "Deque should remember its items");
        }
예제 #2
0
        public void Deque_AddToBack_AddsItem()
        {
            Deque <int> q = new Deque <int>();

            q.AddToBack(13);
            Assert.AreEqual(1, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 13 }), "Deque should remember its items");
        }
예제 #3
0
        public void RemoveFromFront_MaintainsOrder()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5 });

            q.RemoveFromFront();
            Assert.AreEqual(4, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 2, 3, 4, 5 }), "Deque should remember its items");
        }
예제 #4
0
        public void RemoveEmptyRange_DoesNothing()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5 });

            q.RemoveRange(3, 0);
            Assert.AreEqual(5, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 1, 2, 3, 4, 5 }), "Deque should remember its items");
        }
예제 #5
0
        public void RemoveRange_AtEnd_MaintainsOrder()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5, 6, 7 });

            q.RemoveRange(5, 2);
            Assert.AreEqual(5, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 1, 2, 3, 4, 5 }), "Deque should remember its items");
        }
예제 #6
0
        public void InsertRange_AtBack_MaintainsOrder()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5 });

            q.InsertRange(5, new[] { 13, 17 });
            Assert.AreEqual(7, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 1, 2, 3, 4, 5, 13, 17 }), "Deque should remember its items");
        }
예제 #7
0
        public void Deque_RemoveAtBack_MaintainsOrder()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5 });

            q.RemoveAt(4);
            Assert.AreEqual(4, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 1, 2, 3, 4 }), "Deque should remember its items");
        }
예제 #8
0
        public void Deque_InsertAtBack_MaintainsOrder()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5 });

            q.Insert(5, 13);
            Assert.AreEqual(6, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 1, 2, 3, 4, 5, 13 }), "Deque should remember its items");
        }
예제 #9
0
        public void Deque_InsertRange_InsertsRange()
        {
            Deque <int> q = new Deque <int>();

            q.InsertRange(0, new[] { 13, 17 });
            Assert.AreEqual(2, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 13, 17 }), "Deque should remember its items");
        }
예제 #10
0
        public void Deque_AfterBackResize_RemembersItems()
        {
            Deque <int> q = new Deque <int>(1);

            q.Add(13);
            q.Add(17);
            Assert.AreEqual(2, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 13, 17 }), "Deque should remember its items");
        }
예제 #11
0
        public void Deque_AddToFront_AddsItemInOrder()
        {
            Deque <int> q = new Deque <int>();

            q.AddToFront(13);
            q.AddToFront(17);
            Assert.AreEqual(2, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 17, 13 }), "Deque should remember its items");
        }
예제 #12
0
        public void SetItem_UpdatesItems()
        {
            Deque <int> q = new Deque <int>(new[] { 1, 2, 3, 4, 5 });

            q.AddToFront(13);
            q[3] = 17;
            Assert.AreEqual(6, q.Count, "Deque should remember its items");
            Assert.IsTrue(q.SequenceEqual(new[] { 13, 1, 2, 17, 4, 5 }), "Deque should remember its items");
        }
예제 #13
0
        public void Capacity_ResizeWhileSplit_MaintainsOrder()
        {
            Deque <int> q = new Deque <int>(4);

            q.InsertRange(0, new[] { 13, 17, 19 });
            q.Insert(0, 11);
            q.Add(23);
            Assert.IsTrue(q.SequenceEqual(new[] { 11, 13, 17, 19, 23 }), "Deque should remember its items");
        }