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 DequeEnumerator(Deque owner)
{
this.owner = owner;
currentNode = owner.front;
this.version = owner.version;
}
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>());
}
