/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> private void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); // Must not be run more than once. if (m_isDisposed) { return; } if (disposing) { if (m_messages != null) { while (m_messages.Count > 0) { m_messages.Remove(); } } } // Dispose unmanaged resources here, whether disposing is true or false. m_master = null; m_receiver = null; m_messages = null; m_isDisposed = true; }
void Fill(int start, int end, ref int count, SafeQueue queue) { for (int i = start; i < end; i++) { queue.Add(i); count++; Assert.AreEqual(count, queue.Count); } }
void Check(int start, int end, ref int count, SafeQueue queue) { for (int i = start; i < end; i++) { int result = (int)queue.Remove(); count--; Assert.AreEqual(i, result); Assert.AreEqual(count, queue.Count); } }
public void QueueNormal() { SafeQueue queue = new SafeQueue(); int count = 0; // fill the first 49 of 100 inital slots. Just short of causing grow. Fill(0, 49, ref count, queue); // Remove the first 40. Check(0, 40, ref count, queue); Assert.AreEqual(9, count); // Add and remove another 40. Fill(49, 89, ref count, queue); Check(40, 80, ref count, queue); Assert.AreEqual(9, count); // And another group. This checks the situation where the queue is wrapped around during grow. Fill(89, 149, ref count, queue); Assert.AreEqual(69, count); Check(80, 149, ref count, queue); Assert.AreEqual(0, count); // Re-establishes a situation for an earlier group of tests. Fill(0, 50, ref count, queue); Check(0, 20, ref count, queue); // Add another 55; this will force a grow, we now have 200 slots Fill(500, 555, ref count, queue); // Remove the next 30. Down to 55. Check(20, 50, ref count, queue); // Remove 10 more. Down to 45. Check(500, 510, ref count, queue); // Add another 50 Fill(600, 650, ref count, queue); // Remove the rest of the 500 series, just to check Check(510, 555, ref count, queue); // Remove the rest of the 600 series, just to check, and make sure we can be back to 0. Check(600, 650, ref count, queue); Assert.AreEqual(0, queue.Count); }
public void QueueNormal() { SafeQueue queue = new SafeQueue(); int count = 0; // fill the first 49 of 100 inital slots. Just short of causing grow. Fill(0, 49, ref count, queue); // Remove the first 40. Check(0, 40, ref count, queue); Assert.AreEqual(9, count); // Add and remove another 40. Fill(49, 89, ref count, queue); Check(40, 80, ref count, queue); Assert.AreEqual(9, count); // And another group. This checks the situation where the queue is wrapped around during grow. Fill(89, 149, ref count, queue); Assert.AreEqual(69, count); Check(80, 149, ref count, queue); Assert.AreEqual(0, count); // Re-establishes a situation for an earlier group of tests. Fill(0,50, ref count, queue); Check(0, 20, ref count, queue); // Add another 55; this will force a grow, we now have 200 slots Fill(500, 555, ref count, queue); // Remove the next 30. Down to 55. Check(20, 50, ref count, queue); // Remove 10 more. Down to 45. Check(500, 510, ref count, queue); // Add another 50 Fill(600, 650, ref count, queue); // Remove the rest of the 500 series, just to check Check(510, 555, ref count, queue); // Remove the rest of the 600 series, just to check, and make sure we can be back to 0. Check(600, 650, ref count, queue); Assert.AreEqual(0, queue.Count); }
void Check(int start, int end, ref int count, SafeQueue queue) { for (int i = start; i < end; i++) { int result = (int) queue.Remove(); count--; Assert.AreEqual(i, result); Assert.AreEqual(count, queue.Count); } }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> private void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { if (m_messages != null) { while (m_messages.Count > 0) m_messages.Remove(); } } // Dispose unmanaged resources here, whether disposing is true or false. m_master = null; m_receiver = null; m_messages = null; m_isDisposed = true; }