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(); }