public void CopyTo() { int[] array = new int[5]; var deque = new Deque<int>(new[] { 2, 3, 4 }); deque.CopyTo(array, 2); Assert.AreEqual(0, array[0]); Assert.AreEqual(0, array[1]); Assert.AreEqual(2, array[2]); Assert.AreEqual(3, array[3]); Assert.AreEqual(4, array[4]); array = new int[5]; deque = new Deque<int>(); deque.EnqueueHead(3); deque.EnqueueHead(2); deque.EnqueueTail(4); deque.CopyTo(array, 2); Assert.AreEqual(0, array[0]); Assert.AreEqual(0, array[1]); Assert.AreEqual(2, array[2]); Assert.AreEqual(3, array[3]); Assert.AreEqual(4, array[4]); Assert.That(() => deque.CopyTo(null, 0), Throws.TypeOf<ArgumentNullException>()); Assert.That(() => deque.CopyTo(new int[5], -1), Throws.TypeOf<ArgumentOutOfRangeException>()); Assert.That(() => deque.CopyTo(new int[2], 0), Throws.TypeOf<ArgumentException>()); Assert.That(() => deque.CopyTo(new int[5], 5), Throws.TypeOf<ArgumentException>()); Assert.That(() => deque.CopyTo(new int[5], 4), Throws.TypeOf<ArgumentException>()); }
public void Add() { var deque = new Deque<int>(); ((ICollection<int>)deque).Add(456); Assert.AreEqual(1, deque.Count); Assert.AreEqual(456, deque.Head); Assert.AreEqual(456, deque.Tail); Assert.AreEqual(456, deque[0]); }
public void TestAddFirst() { Deque<int> intDeque = new Deque<int>(16); for(int item = 0; item < 48; ++item) { intDeque.AddFirst(item); } for(int item = 0; item < 48; ++item) { Assert.AreEqual(47 - item, intDeque[item]); } }
public void TestRemoveLast() { Deque<int> intDeque = new Deque<int>(16); for(int item = 0; item < 48; ++item) { intDeque.AddLast(item); } for(int item = 0; item < 48; ++item) { Assert.AreEqual(47 - item, intDeque.Last); Assert.AreEqual(48 - item, intDeque.Count); intDeque.RemoveLast(); } }
public void Clear() { var deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); deque.Clear(); Assert.AreEqual(0, deque.Count); deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); deque.EnqueueHead(1); deque.EnqueueHead(0); deque.Clear(); Assert.AreEqual(0, deque.Count); deque = new Deque<int>(); deque.EnqueueHead(1); deque.EnqueueHead(0); deque.Clear(); Assert.AreEqual(0, deque.Count); }
private static void PopulateDequePushFront(Deque deque) { deque.Clear(); for(int i = 0; i < ElementCount; i++) { deque.PushFront(i); } Debug.Assert(deque.Count == ElementCount); int j = ElementCount - 1; foreach(int i in deque) { Debug.Assert(i == j); j--; } }
private static void TestClone(Deque deque) { deque.Clear(); PopulateDequePushBack(deque); Deque deque2 = (Deque)deque.Clone(); Debug.Assert(deque.Count == deque2.Count); IEnumerator d2 = deque2.GetEnumerator(); d2.MoveNext(); foreach(object obj in deque) { Debug.Assert(obj.Equals(d2.Current)); d2.MoveNext(); } }
public void Contains() { var deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); Assert.IsTrue(deque.Contains(2)); Assert.IsTrue(deque.Contains(6)); Assert.IsFalse(deque.Contains(7)); deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); deque.EnqueueHead(1); deque.EnqueueHead(0); Assert.IsTrue(deque.Contains(0)); Assert.IsTrue(deque.Contains(6)); Assert.IsFalse(deque.Contains(7)); var deque2 = new Deque<string>(); deque2.EnqueueHead("item 1"); deque2.EnqueueHead(null); Assert.IsTrue(deque2.Contains("item 1")); Assert.IsTrue(deque2.Contains(null)); Assert.IsFalse(deque2.Contains(String.Empty)); Assert.IsFalse(deque2.Contains("item 2")); }
public void ToArray() { var deque = new Deque<int>(); var array = deque.ToArray(); Assert.AreEqual(0, array.Length); deque = new Deque<int>(new[] { 2, 3, 4 }); array = deque.ToArray(); Assert.AreEqual(3, array.Length); Assert.AreEqual(2, array[0]); Assert.AreEqual(3, array[1]); Assert.AreEqual(4, array[2]); }
public void TrimExcess() { var deque = new Deque<int>(); deque.TrimExcess(); deque = new Deque<int>(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }); deque.TrimExcess(); deque.Clear(); deque.TrimExcess(); }
public void SyncRoot() { var deque = new Deque<int>(); object syncRoot = ((ICollection)deque).SyncRoot; Assert.IsNotNull(syncRoot); Assert.AreSame(syncRoot, ((ICollection)deque).SyncRoot); }
public void Tail() { var deque = new Deque<int>(); Assert.That(() => { int i = deque.Tail; }, Throws.TypeOf<InvalidOperationException>()); Assert.That(() => { deque.Tail = 0; }, Throws.TypeOf<InvalidOperationException>()); deque.EnqueueHead(123); Assert.AreEqual(123, deque.Tail); deque.EnqueueTail(234); Assert.AreEqual(234, deque.Tail); deque.EnqueueHead(345); Assert.AreEqual(234, deque.Tail); deque.Tail = 1; Assert.AreEqual(1, deque.Tail); deque.DequeueHead(); Assert.AreEqual(1, deque.Tail); deque.DequeueTail(); Assert.AreEqual(123, deque.Head); }
public void CopyToShouldNotThrowIfEmpty() { int[] array = new int[0]; var deque = new Deque<int>(); deque.CopyTo(array, 0); }
public void IsSynchronizedShouldBeFalse() { var deque = new Deque<int>(); Assert.IsFalse(((ICollection)deque).IsSynchronized); }
public void Count() { var deque = new Deque<int>(); Assert.AreEqual(0, deque.Count); deque.EnqueueHead(1); deque.EnqueueHead(0); deque.EnqueueTail(2); deque.EnqueueTail(3); deque.EnqueueTail(4); deque.DequeueHead(); deque.DequeueTail(); Assert.AreEqual(3, deque.Count); deque.Clear(); Assert.AreEqual(0, deque.Count); }
private static void TestContains(Deque deque) { deque.Clear(); PopulateDequePushBack(deque); for(int i = 0; i < deque.Count; i++) { Debug.Assert(deque.Contains(i)); } Debug.Assert(!deque.Contains(ElementCount)); }
public void Enumerator() { var deque = new Deque<int>(new[] { 2, 3, 4 }); Assert.IsNotNull(((IEnumerable<int>)deque).GetEnumerator()); Assert.IsNotNull(((IEnumerable)deque).GetEnumerator()); Deque<int>.Enumerator enumerator = deque.GetEnumerator(); Assert.AreEqual(0, enumerator.Current); Assert.That(() => ((IEnumerator)enumerator).Current, Throws.TypeOf<InvalidOperationException>()); Assert.IsTrue(enumerator.MoveNext()); Assert.AreEqual(2, enumerator.Current); Assert.AreEqual(2, ((IEnumerator)enumerator).Current); Assert.IsTrue(enumerator.MoveNext()); Assert.AreEqual(3, enumerator.Current); Assert.AreEqual(3, ((IEnumerator)enumerator).Current); Assert.IsTrue(enumerator.MoveNext()); Assert.AreEqual(4, enumerator.Current); Assert.AreEqual(4, ((IEnumerator)enumerator).Current); Assert.IsFalse(enumerator.MoveNext()); Assert.AreEqual(0, enumerator.Current); Assert.That(() => ((IEnumerator)enumerator).Current, Throws.TypeOf<InvalidOperationException>()); enumerator.Reset(); Assert.IsTrue(enumerator.MoveNext()); Assert.AreEqual(2, enumerator.Current); enumerator.Dispose(); Assert.AreEqual(0, enumerator.Current); Assert.IsFalse(enumerator.MoveNext()); Assert.That(() => ((IEnumerator)enumerator).Current, Throws.TypeOf<InvalidOperationException>()); enumerator = deque.GetEnumerator(); enumerator.MoveNext(); deque.EnqueueTail(5); Assert.That(() => enumerator.MoveNext(), Throws.TypeOf<InvalidOperationException>()); Assert.That(() => enumerator.Reset(), Throws.TypeOf<InvalidOperationException>()); }
public DequeEnumerator(Deque owner) { this.owner = owner; currentNode = owner.front; this.version = owner.version; }
public void EnqueueDequeueTail() { var deque = new Deque<int>(); Assert.That(() => deque.DequeueTail(), Throws.TypeOf<InvalidOperationException>()); deque.EnqueueHead(1); Assert.AreEqual(1, deque.Count); Assert.AreEqual(1, deque.DequeueTail()); Assert.AreEqual(0, deque.Count); deque = new Deque<int>(new[] { 2, 3, 4 }); Assert.AreEqual(4, deque.DequeueTail()); deque.EnqueueTail(0); Assert.AreEqual(3, deque.Count); Assert.AreEqual(0, deque.DequeueTail()); Assert.AreEqual(2, deque.Count); }
public void DefaultConstructor() { var deque = new Deque<int>(); Assert.AreEqual(0, deque.Count); }
public void CreateWithCapacity() { var deque = new Deque<int>(0); deque = new Deque<int>(1); deque = new Deque<int>(10); Assert.That(() => { new Deque<int>(-1); }, Throws.TypeOf<ArgumentOutOfRangeException>()); }
public void UnsupportedMethods() { var deque = new Deque<int>(); Assert.That(() => ((ICollection<int>)deque).Remove(1), Throws.TypeOf<NotSupportedException>()); Assert.That(() => ((IList<int>)deque).RemoveAt(0), Throws.TypeOf<NotSupportedException>()); Assert.That(() => ((IList<int>)deque).Insert(0, 1), Throws.TypeOf<NotSupportedException>()); }
/// <summary> /// Returns a synchronized (thread-safe) wrapper for the Deque. /// </summary> /// <param name="deque"> /// The Deque to synchronize. /// </param> /// <returns> /// A synchronized wrapper around the Deque. /// </returns> public static Deque Synchronized(Deque deque) { #region Require if(deque == null) { throw new ArgumentNullException("deque"); } #endregion return new SynchronizedDeque(deque); }
public void IndexOf() { var deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); Assert.AreEqual(0, deque.IndexOf(2)); Assert.AreEqual(4, deque.IndexOf(6)); Assert.AreEqual(-1, deque.IndexOf(7)); deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); deque.EnqueueHead(1); deque.EnqueueHead(0); Assert.AreEqual(0, deque.IndexOf(0)); Assert.AreEqual(2, deque.IndexOf(2)); Assert.AreEqual(6, deque.IndexOf(6)); Assert.AreEqual(-1, deque.IndexOf(7)); var deque2 = new Deque<string>(); deque2.EnqueueHead("item 1"); deque2.EnqueueHead(null); Assert.AreEqual(1, deque2.IndexOf("item 1")); Assert.AreEqual(0, deque2.IndexOf(null)); Assert.AreEqual(-1, deque2.IndexOf(String.Empty)); Assert.AreEqual(-1, deque2.IndexOf("item 2")); }
public void CreateFromCollection() { var deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); Assert.AreEqual(5, deque.Count); Assert.AreEqual(2, deque[0]); Assert.AreEqual(3, deque[1]); Assert.AreEqual(4, deque[2]); Assert.AreEqual(5, deque[3]); Assert.AreEqual(6, deque[4]); Assert.That(() => { new Deque<int>(null); }, Throws.TypeOf<ArgumentNullException>()); }
internal void postResponses() { sbyte recvNum = 0; IList<AsyncTask> respList = null; if (_responseQueue.Count > 0 && _postNumOnce > 0) { respList = new Deque<AsyncTask>(); Monitor.Enter(_responseQueue); //++ while (_responseQueue.Count > 0 && recvNum < _postNumOnce) { respList.Add(_responseQueue[0]); _responseQueue.RemoveAt(0); ++recvNum; } Monitor.Exit(_responseQueue); //-- } if (respList != null) { AsyncTask task = null; for (int i = 0; i < respList.Count; ++i) { task = respList[i]; Debug.Assert(task != null && task.onCompleteTask != null); task.onCompleteTask(task, task.errorCode, task.resultDict); task.resultDict = null; } } }
public void IsReadOnlyShouldBeFalse() { var deque = new Deque<int>(); Assert.IsFalse(((ICollection<int>)deque).IsReadOnly); }
/// <summary> /// Creates a shallow copy of the Deque. /// </summary> /// <returns> /// A shallow copy of the Deque. /// </returns> public virtual object Clone() { Deque clone = new Deque(this); clone.version = this.version; return clone; }
public SynchronizedDeque(Deque deque) { #region Require if(deque == null) { throw new ArgumentNullException("deque"); } #endregion this.deque = deque; this.root = deque.SyncRoot; }
public void Indexer() { var deque = new Deque<int>(new[] { 2, 3, 4, 5, 6 }); Assert.AreEqual(5, deque.Count); Assert.AreEqual(2, deque[0]); Assert.AreEqual(3, deque[1]); Assert.AreEqual(4, deque[2]); Assert.AreEqual(5, deque[3]); Assert.AreEqual(6, deque[4]); deque[0] = 1; deque[4] = 4; Assert.AreEqual(1, deque[0]); Assert.AreEqual(4, deque[4]); Assert.That(() => { int i = deque[-1]; }, Throws.TypeOf<ArgumentOutOfRangeException>()); Assert.That(() => { int i = deque[5]; }, Throws.TypeOf<ArgumentOutOfRangeException>()); Assert.That(() => { deque[-1] = 0; }, Throws.TypeOf<ArgumentOutOfRangeException>()); Assert.That(() => { deque[-5] = 0; }, Throws.TypeOf<ArgumentOutOfRangeException>()); deque.Clear(); Assert.That(() => { int i = deque[0]; }, Throws.TypeOf<ArgumentOutOfRangeException>()); Assert.That(() => { int i = deque[0]; }, Throws.TypeOf<ArgumentOutOfRangeException>()); Assert.That(() => { deque[0] = 0; }, Throws.TypeOf<ArgumentOutOfRangeException>()); Assert.That(() => { deque[0] = 0; }, Throws.TypeOf<ArgumentOutOfRangeException>()); }