static void Main(string[] args)
{
var arrayQueue = new ArrayQueue <string>();
arrayQueue.Enqueue("1");
arrayQueue.Enqueue("2");
arrayQueue.Enqueue("3");
arrayQueue.Enqueue("4");
arrayQueue.Enqueue("5");
arrayQueue.Dequeue();
arrayQueue.Dequeue();
arrayQueue.Dequeue();
arrayQueue.Dequeue();
var linkedListQueue = new LinkedListQueue <string>();
linkedListQueue.Enqueue("1");
linkedListQueue.Enqueue("2");
linkedListQueue.Enqueue("3");
linkedListQueue.Enqueue("4");
linkedListQueue.Enqueue("5");
linkedListQueue.Dequeue();
linkedListQueue.Dequeue();
linkedListQueue.Dequeue();
linkedListQueue.Dequeue();
}
static void Main(string[] args)
{
int count = 1;
ArrayQueue <string> arr = new ArrayQueue <string>(count);
string s = "cfvfd";
for (int i = 0; i < count; i++)
{
arr.Enqueue("элемент" + i);
}
IEnumerator <string> el1 = arr.GetEnumerator();
arr.Enqueue(s);
arr.Enqueue(s);
arr.Enqueue(s);
arr.Enqueue(s);
foreach (string el in arr)
{
Console.WriteLine(el);
}
Console.WriteLine("//--//--//");
Console.WriteLine();
Console.WriteLine(arr.Dequeue());
// Console.WriteLine(arr.Peek());
// arr.Clear();
Console.ReadLine();
}
public void DequeuingAllExceptOne()
{
var queue = new ArrayQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
queue.Enqueue(i);
}
int lastItem = int.MinValue;
for (int i = 0; i < itemCount - 1; i++)
{
if (lastItem > queue.Dequeue())
{
Assert.Fail();
}
}
int trueCount = 0;
foreach (var item in queue)
{
trueCount++;
}
Assert.IsTrue(queue.Count == 1 &&
trueCount == 1);
}
public void EnqueuingItemsAndCheckingIfIteratedInCorrectly()
{
var queue = new ArrayQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
queue.Enqueue(i);
}
int trueCount = 0;
int itemNum = 0;
foreach (var item in queue)
{
if (itemNum++ != item)
{
Assert.Fail();
}
trueCount++;
}
Assert.IsTrue(queue.Count == itemCount &&
queue.Count == trueCount);
}
public void ClearAll()
{
_normQueue_int = new Queue <int>();
_normQueue_string = new Queue <string>();
_custQueue_int = new ArrayQueue <int>();
_custQueue_string = new ArrayQueue <string>();
}
public void intNumbEnter()
{
//arrange
int[] expected_ar = { 5, 6, 7 };
//act
ArrayQueue <int> arr = new ArrayQueue <int>(3);
arr.Enqueue(5);
arr.Enqueue(6);
arr.Enqueue(7);
int[] actual_ar = new int[3];
int i = 0;
while (!arr.IsEmpty())
{
actual_ar[i] = arr.Peek();
arr.Dequeue();
i++;
}
//foreach(var elem in arr)
//{
// actual_ar[i] = elem;
// i++;
//}
//assert
Assert.AreEqual(true, arr.isEmpty);
CollectionAssert.AreEqual(expected_ar, actual_ar);
}
public void EnqueueAndDequeue()
{
var students = new Student[]
{
new Student {
No = 1, Name = "李1", Score = 22.1
},
new Student {
No = 2, Name = "李2", Score = 32.3
},
new Student {
No = 3, Name = "李3", Score = 42.5
},
new Student {
No = 4, Name = "李4", Score = 45
}
};
var arrayQueue = new ArrayQueue <Student>(3);
foreach (var student in students)
{
var result = arrayQueue.Enqueue(student);
}
var deqStudent = new Student();
arrayQueue.Dequeue(out deqStudent);
arrayQueue.Enqueue(students[3]);
}
public void TestDequeueEmptyQueueThrows()
{
var queue = new ArrayQueue <int>(5);
var ex = Assert.Throws <InvalidOperationException>(() => queue.Dequeue());
Assert.AreEqual("Queue is empty", ex.Message);
}
private static void ArrayQueueExercise()
{
try
{
ArrayQueue qArray = new ArrayQueue(4);
qArray.Enqueue(10);
qArray.Enqueue(20);
qArray.Enqueue(30);
qArray.Enqueue(40);
Console.WriteLine(qArray.ToString());
Console.WriteLine($"Peek {qArray.Peek()}");
Console.WriteLine($"Is Empty {qArray.isEmpty()}");
Console.WriteLine($"Is full {qArray.isFull()}");
Console.WriteLine(qArray.Dequeue());
Console.WriteLine(qArray.Dequeue());
qArray.Enqueue(50);
Console.WriteLine(qArray.Dequeue());
Console.WriteLine(qArray.Dequeue());
Console.WriteLine(qArray.Dequeue());
Console.WriteLine(qArray.Dequeue());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void TestEnqueue()
{
var queue = new ArrayQueue <int>(5);
queue.Enqueue(10);
Assert.AreEqual(1, queue.Count);
}
private static void QueueTests()
{
var arrayValueTypeQueue = new ArrayQueue <int>();
Console.WriteLine("ArrayQueue<int> test:");
TestValueTypeQueue(arrayValueTypeQueue);
Console.WriteLine("=======================================");
Console.WriteLine();
var linkedListValueTypeQueue = new LinkedListQueue <int>();
Console.WriteLine("LinkedListQueue<int> test:");
TestValueTypeQueue(linkedListValueTypeQueue);
Console.WriteLine("=======================================");
Console.WriteLine();
var arrayReferenceTypeQueue = new ArrayQueue <string>();
Console.WriteLine("ArrayQueue<string> test:");
TestReferenceTypeQueue(arrayReferenceTypeQueue);
Console.WriteLine("=======================================");
Console.WriteLine();
var linkedListReferenceTypeQueue = new LinkedListQueue <string>();
Console.WriteLine("LinkedListQueue<string> test:");
TestReferenceTypeQueue(linkedListReferenceTypeQueue);
Console.WriteLine("=======================================");
Console.WriteLine();
}
public void ConvertingQueueToArray()
{
var queue = new ArrayQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
queue.Enqueue(i);
}
var array = queue.ToArray();
int trueCount = 0;
for (int i = 0; i < itemCount; i++)
{
if (array[i] != i)
{
Assert.Fail();
}
trueCount++;
}
Assert.IsTrue(queue.Count == itemCount &&
queue.Count == trueCount);
}
private void BreadthFirstSearch(LinkedList.LinkedList <T> visitedNodes)
{
IQueue <int> queue = new ArrayQueue <int>(_nodes.Count);
bool[] visited = new bool[_nodes.Count];
bool[] inqueue = new bool[_nodes.Count];
queue.Enqueue(0);
inqueue[0] = true;
while (!queue.IsEmpty())
{
var n = queue.Dequeue();
visited[n] = true;
inqueue[n] = false;
visitedNodes.Insert(_nodes[n]);
foreach (var v in GetAdjacentVertices(n))
{
if (!visited[v] && !inqueue[v])
{
queue.Enqueue(v);
inqueue[v] = true;
}
}
}
}
public PublisherSkipLastTimed(ISubscriber <T> actual, TimeSpan time, IScheduler scheduler)
{
this.actual.Init(actual);
this.scheduler = scheduler;
this.time = time;
this.queue = new ArrayQueue <TimedValue>();
}
public PublisherTakeLastTimed(ISubscriber <T> actual, long maxAge, IScheduler scheduler)
{
this.actual = actual;
this.scheduler = scheduler;
this.maxAge = maxAge;
this.q = new ArrayQueue <TimedValue>();
}
public void DequeueOnEmptyQueueThrowsQueueEmptyExceptionTest()
{
ArrayQueue target = new ArrayQueue(); // TODO: Initialize to an appropriate value
target.Dequeue();
Assert.Fail("Dequeued from empty queue didn't throw QueueEmptyException");
}
public void InitializationWithZeroCapacityAndEnqueuingItemsAfterwards()
{
var queue = new ArrayQueue <int>(0);
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
queue.Enqueue(i);
}
int trueCount = 0;
int lastItem = int.MinValue;
foreach (var item in queue)
{
if (lastItem > item)
{
Assert.Fail();
}
lastItem = item;
trueCount++;
}
Assert.IsTrue(queue.Count == itemCount &&
queue.Count == trueCount);
}
[TestMethod] // Тест заполнения очереди
public void AddTest()
{
int n = 2;
ArrayQueue<object> data = new ArrayQueue<object>(n);
data.Add(8);
data.Add(6);
}
public void EnqueuingItemsOneByOne()
{
var queue = new ArrayQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
queue.Enqueue(i);
}
int trueCount = 0;
int lastItem = int.MinValue;
foreach (var item in queue)
{
if (lastItem > item)
{
Assert.Fail();
}
lastItem = item;
trueCount++;
}
Assert.IsTrue(queue.Count == itemCount &&
queue.Count == trueCount);
}
static void Main(string[] args)
{
IQueue <int> q = new ArrayQueue <int>(10);
for (int i = 0; i < 10; i++)
{
q.Enqueue(i);
}
print(q);
q.Enqueue(10);
print(q);
q.Enqueue(11);
print(q);
for (int i = 12; i < 100; i++)
{
q.Enqueue(i);
}
print(q);
Console.WriteLine();
Random r = new Random();
for (int i = 0; i < length; i++)
{
arr[i] = r.NextDouble();
}
Console.WriteLine("testing measurement functions");
Diagnostics.MeasureAndPrintToConsole("Random for loop", 10, MeasureMerge);
Diagnostics.MeasureAndPrintToConsole("Random for loop", 10, MeasureBubble);
Console.ReadKey();
}
public void TestRemoveAt1()
{
ArrayQueue <object> queue = new ArrayQueue <object>(100, 3);
for (int i = 1; i <= 16000; i++)
{
Assert.AreEqual(i, queue.Enqueue(i.ToString()));
}
Assert.AreEqual(16000, queue.Count);
for (int i = 1; i <= 200; i++)
{
Assert.IsTrue(queue.Remove((500 + i).ToString()));
Assert.AreEqual(16000 - i, queue.Count);
}
for (int i = 1; i <= 100; i++)
{
Assert.IsTrue(queue.Remove(i.ToString()));
Assert.AreEqual((16000 - 200) - i, queue.Count);
}
Assert.IsFalse(queue.Remove(16001.ToString()));
for (int i = queue.Count; i-- > 0;)
{
queue.Dequeue();
}
Assert.AreEqual(0, queue.Count);
}
public void InitializingArrayQueueWithCollection()
{
var queue = new ArrayQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
queue.Enqueue(i);
}
var queue2 = new ArrayQueue <int>(queue);
int trueCount = 0;
int lastItem = int.MinValue;
foreach (var item in queue2)
{
if (lastItem > item)
{
Assert.Fail();
}
lastItem = item;
trueCount++;
}
Assert.IsTrue(queue.Count == itemCount &&
queue2.Count == itemCount &&
queue2.Count == trueCount);
}
public void Push_OneElement_ShouldReturnItWhenPeek()
{
var aq = new ArrayQueue<bool>();
aq.Push(true);
Assert.AreEqual(true, aq.Peek());
}
public void EnqueuingAfterClearingCollection()
{
var stack = new ArrayQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
stack.Enqueue(i);
}
stack.Clear();
for (int i = 0; i < itemCount; i++)
{
stack.Enqueue(i);
}
int trueCount = 0;
int lastItem = int.MinValue;
foreach (var item in stack)
{
if (lastItem > item)
{
Assert.Fail();
}
lastItem = item;
trueCount++;
}
Assert.IsTrue(stack.Count == itemCount &&
stack.Count == trueCount);
}
static void method(ArrayQueue q)
{
for (int i = 0; i < q.Queue.Length; i++)
{
Console.WriteLine(q.Queue[i]);
}
Console.WriteLine();
}
internal EventPump()
{
this.syncRoot = new object();
this.frontBuffer = new ArrayQueue <Event>(64);
this.backBuffer = new ArrayQueue <Event>(64);
this.eventDispatchers = new ArrayList <EventDispatcher>(32);
this.eventMapping = new EventMapping();
}
[TestMethod] // IDisposable
public void DisposeTest()
{
int n = 2;
ArrayQueue<object> data = new ArrayQueue<object>(n);
data.Add(6);
data.Add(15);
data.Dispose();
}
[TestMethod] // ICloneable
public void CloneTest()
{
int n = 2;
ArrayQueue<object> data = new ArrayQueue<object>(n);
data.Add(8);
data.Add(10);
data.Clone();
}
public void TestToStringReturnsCorrectValue()
{
var queue = new ArrayQueue <int>(10);
queue.Enqueue(1);
queue.Enqueue(2);
Assert.AreEqual("1,2", queue.ToString());
}
public PublisherBufferOverlap(ISubscriber <C> actual, Func <C> bufferFactory, int size, int skip)
{
this.actual = actual;
this.bufferFactory = bufferFactory;
this.size = size;
this.skip = skip;
this.buffers = new ArrayQueue <C>();
}
public PublisherWindowOverlap(ISubscriber <IPublisher <T> > actual, int size, int skip)
{
this.actual = actual;
this.size = size;
this.skip = skip;
this.wip = 1;
this.q = new ArrayQueue <IProcessor <T, T> >();
}
[TestMethod] // IEnumerable
public void EnumerableTest()
{
int n = 2;
ArrayQueue<object> data = new ArrayQueue<object>(n);
data.Add(8);
data.Add(10);
data.GetEnumerator();
}
private void GeneratePopulatedExample()
{
PopulatedArrayQueue = new ArrayQueue <string>();
foreach (var item in Items)
{
PopulatedArrayQueue.Enqueue(item);
}
}
//----------------------------------//
/// <summary>
/// Initialize a cache with the specified max number of items.
/// </summary>
public CacheValue(long maxCount = 1024)
{
MaxCount = maxCount;
_queue = new ArrayQueue <TValue>();
_lookup = new Dictionary <TValue, int>();
_lock = new Lock();
}
public void Push_OneElement_ShouldReturnInWhenPop()
{
var aq = new ArrayQueue<bool>();
aq.Push(true);
Assert.AreEqual(true, aq.Pop());
Assert.Throws<InvalidOperationException>(() => aq.Pop());
}
public void Ctor_PassCapacity_CorrectCapacity()
{
const int capacity = 8;
var queue = new ArrayQueue <int>(capacity);
Assert.AreEqual(capacity, queue.Capacity);
}
public static void run()
{
/*IQueue queue = new LinkedQueue();
queue.enqueue(5);
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(1);*/
IQueue queue = new ArrayQueue();
queue.enqueue(5);
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(1);
}
public void TestGrow()
{
ArrayQueue<string> queue = new ArrayQueue<string>(3, 5);
Assert.AreEqual(3, queue.Capacity);
queue.Enqueue("a");
queue.Enqueue("b");
Assert.AreEqual(3, queue.Capacity);
queue.Enqueue("c");
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Enqueue("" + ('d' + i));
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Dequeue();
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Enqueue("" + ('d' + i));
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Dequeue();
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Enqueue("" + ('d' + i));
Assert.AreEqual(8, queue.Capacity);
queue.Enqueue("z");
Assert.AreEqual(13, queue.Capacity);
queue.Clear();
Assert.AreEqual(13, queue.Capacity);
for (int i = 0; i < 12; i++)
queue.Enqueue("" + ('a' + i));
Assert.AreEqual(13, queue.Capacity);
queue.Clear();
Assert.AreEqual(13, queue.Capacity);
for (int i = 0; i < 12; i++)
queue.Enqueue("" + ('a' + i));
Assert.AreEqual(13, queue.Capacity);
}
static void test8()
{
ArrayQueue<int> queue = new ArrayQueue<int>(3);
queue.Enqueue(1);
queue.Enqueue(2);
queue.Dequeue();
queue.Enqueue(3);
queue.Dequeue();
queue.Enqueue(4);
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
}
/// <summary>
/// Start the QueuedThreadPool.
/// Construct the minimum number of threads.
/// </summary>
protected override void DoStart()
{
if (_maxThreads<_minThreads || _minThreads<=0)
throw new ArgumentException("!0<minThreads<maxThreads");
_threads = new HashSet<ThreadPoolWorker>();
//_idleQue = new QueueList<QueuedThreadPoolWorker>(_maxThreads);
_idleQue = new ArrayQueue<ThreadPoolWorker>(_maxThreads);
//_jobsQue = new QueueList<ThreadStart>(_maxThreads);
_jobsQue = new ArrayQueue<ThreadStart>(_maxThreads, _maxThreads);
for (int i=0;i<_minThreads;i++)
{
NewThread();
}
}
public override void Init()
{
queue = new ArrayQueue<int> (5);
}
public void TestRemoveAt1()
{
ArrayQueue<object> queue = new ArrayQueue<object>(100, 3);
for (int i = 1; i <= 16000; i++)
{
Assert.AreEqual(i, queue.Enqueue(i.ToString()));
}
Assert.AreEqual(16000, queue.Count);
for (int i = 1; i <= 200; i++)
{
Assert.IsTrue(queue.Remove((500+i).ToString()));
Assert.AreEqual(16000 - i, queue.Count);
}
for (int i = 1; i <= 100; i++)
{
Assert.IsTrue(queue.Remove(i.ToString()));
Assert.AreEqual((16000-200) - i, queue.Count);
}
Assert.IsFalse(queue.Remove(16001.ToString()));
for (int i = queue.Count; i-- > 0; )
{
queue.Dequeue();
}
Assert.AreEqual(0, queue.Count);
}
public void TestRemoveAt2()
{
ArrayQueue<object> queue = new ArrayQueue<object>(100, 3);
int dataSize = 16000;
List<object> list = new List<object>();
for (int i = 1; i <= dataSize; i++)
{
object o = new object();
list.Add(o);
queue.Add(o);
}
Assert.AreEqual(list.Count, queue.Count);
foreach (object item in queue)
{
Assert.IsNotNull(item);
}
Random rand = new Random((int)(DateTime.UtcNow.Ticks/1000));
for (int i = 0; i < list.Count; i++)
{
int r = rand.Next(0, list.Count - 1);
object temp = list[i];
list[i] = list[r];
list[r] = temp;
}
foreach (object item in list)
{
Assert.IsTrue(queue.Remove(item));
queue.Enqueue(item);
Assert.IsTrue(queue.Remove(item));
Assert.IsFalse(queue.Remove(item));
}
Assert.AreEqual(0, queue.Count);
}
public void TestWrap()
{
ArrayQueue<string> queue = new ArrayQueue<string>(3);
Assert.AreEqual(0,queue.Count);
for (int i=0;i<3;i++)
{
queue.Offer("one");
Assert.AreEqual(1,queue.Count);
queue.Offer("two");
Assert.AreEqual(2,queue.Count);
queue.Offer("three");
Assert.AreEqual(3,queue.Count);
Assert.AreEqual("one",queue[0]);
Assert.AreEqual("two",queue[1]);
Assert.AreEqual("three",queue[2]);
Assert.AreEqual("[one, two, three]",queue.ToString());
Assert.AreEqual("one",queue.Dequeue());
Assert.AreEqual(2,queue.Count);
Assert.AreEqual("two", queue.Dequeue());
Assert.AreEqual(1,queue.Count);
Assert.AreEqual("three", queue.Dequeue());
Assert.AreEqual(0,queue.Count);
queue.Offer("xxx");
Assert.AreEqual(1,queue.Count);
Assert.AreEqual("xxx", queue.Dequeue());
Assert.AreEqual(0,queue.Count);
}
}
public void TestRemove()
{
ArrayQueue<string> queue = new ArrayQueue<string>(3,3);
queue.Enqueue("0");
queue.Enqueue("x");
for (int i=1;i<100;i++)
{
queue.Enqueue(""+i);
queue.Enqueue("x");
queue.RemoveAt(queue.Count-3);
queue[queue.Count-3] = queue[queue.Count-3]+"!";
}
for (int i = 0; i < 99; i++)
{
Assert.AreEqual(i + "!", queue[i]);
}
}
[TestMethod] // получение элемента из пустой очереди
public void TakeEmptyTest()
{
int n = 2;
ArrayQueue<object> data = new ArrayQueue<object>(n);
data.Take();
}
