public void stress5()
{
CircularQueue <int?> queue = new CircularQueue <int?>(3);
// we will setup two threads waiting to put to the queue,
// then in a single synchronized step, read two items from
// the queue. the first thread will be woken to put, and
// once done the second thread should be woken by the first.
queue.Put(0);
queue.Put(1);
queue.Put(2);
Assert.IsTrue(queue.IsFull());
Thread t1 = new Thread(
delegate()
{
try
{
Assert.IsTrue(queue.Put(3));
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e);
}
}
);
Thread t2 = new Thread(
delegate()
{
try
{
Assert.IsTrue(queue.Put(4));
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e);
}
}
);
t1.Start();
t2.Start();
// wait until both threads are waiting on queue...
Thread.Sleep(100);
lock (queue)
{
Assert.IsNotNull(queue.Get());
Assert.IsNotNull(queue.Get());
}
harvest(t1);
harvest(t2);
}
public void close3()
{
CircularQueue <int?> queue = new CircularQueue <int?>();
queue.Put(1);
queue.Put(2);
queue.Put(3);
queue.Close();
Assert.AreEqual(1, queue.Get());
Assert.AreEqual(2, queue.Get());
Assert.AreEqual(3, queue.Get());
Assert.IsNull(queue.Get());
}
public void delay2()
{
CircularQueue <int?> queue = new CircularQueue <int?>(1);
Assert.IsTrue(queue.Put(1));
Delay(10, delegate() { Assert.AreEqual(1, queue.Get()); });
Assert.IsTrue(queue.Put(2));
Assert.AreEqual(2, queue.Get());
Assert.IsTrue(queue.Put(1));
Delay(10, delegate() { queue.Close(); });
Assert.IsFalse(queue.Put(2));
Assert.AreEqual(1, queue.Get());
Assert.IsNull(queue.Get());
}
public void full()
{
CircularQueue <int?> queue = new CircularQueue <int?>(1);
Assert.IsFalse(queue.IsFull());
Assert.IsTrue(queue.Put(0));
Assert.IsTrue(queue.IsFull());
Assert.AreEqual(0, queue.Get());
Assert.IsFalse(queue.IsFull());
Assert.IsTrue(queue.Put(0));
Assert.IsFalse(queue.Put(0, -1));
Assert.IsFalse(queue.Put(0, 1));
Assert.IsFalse(queue.Put(0, 10));
}
public void stress3()
{
CircularQueue <int?> queue = new CircularQueue <int?>(1);
int n = 1000;
Thread t = new Thread(
delegate()
{
for (int i = 0; i < n; i++)
{
try
{
queue.Put(i);
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e);
}
}
}
);
t.Start();
for (int i = 0; i < n; i++)
{
Thread.Sleep(5);
Assert.AreEqual(i, queue.Get());
}
}
public void close2()
{
CircularQueue <int?> queue = new CircularQueue <int?>();
Assert.IsFalse(queue.IsClosed());
queue.Close();
Assert.IsTrue(queue.IsClosed());
Assert.IsFalse(queue.Put(0));
Assert.IsFalse(queue.Put(0, -1));
Assert.IsFalse(queue.Put(0, 0));
Assert.IsFalse(queue.Put(0, 1));
queue.Close();
Assert.IsTrue(queue.IsClosed());
}
public void delay1()
{
CircularQueue <int?> queue = new CircularQueue <int?>();
Delay(10, delegate() { queue.Put(99); });
Assert.AreEqual(99, queue.Get());
Delay(10, delegate() { queue.Close(); });
Assert.IsNull(queue.Get());
}
public void putget2()
{
CircularQueue <int?> queue = new CircularQueue <int?>();
Assert.IsNull(queue.Get(1));
Assert.IsNull(queue.Get(-1));
Assert.IsNull(queue.Get(10));
queue.Put(9);
Assert.AreEqual(9, queue.Get(1));
queue.Put(9);
Assert.AreEqual(9, queue.Get(-1));
queue.Put(9);
Assert.AreEqual(9, queue.Get(10));
Assert.IsNull(queue.Get(1));
Assert.IsNull(queue.Get(-1));
Assert.IsNull(queue.Get(10));
/* long t0;
* double t;
*
*
* t0 = HPTimer.Now();
* Assert.IsNull(queue.Get(10));
* t = ( HPTimer.Now() - t0) / 1000000.0;
* assertRelError( 10, t, 1 );
*
*
* t0 = HPTimer.Now();
* Assert.IsNull(queue.Get(20));
* t = (HPTimer.Now() - t0) / 1000000.0;
* assertRelError( 20, t, 1 );
*
*
* t0 = HPTimer.Now();
* Assert.IsNull( queue.Get( 30 ) );
* t = (HPTimer.Now() - t0) / 1000000.0;
* assertRelError( 30, t, 1 ); */
}
public void putget1()
{
CircularQueue <int?> queue = new CircularQueue <int?>();
Assert.AreEqual(0, queue.Count());
Assert.IsTrue(queue.IsEmpty());
Assert.IsFalse(queue.IsFull());
for (int i = 0; i < 10000; i++)
{
queue.Put(i);
Assert.AreEqual(1, queue.Count());
Assert.IsFalse(queue.IsEmpty());
Assert.AreEqual(i, queue.Get());
Assert.AreEqual(0, queue.Count());
Assert.IsTrue(queue.IsEmpty());
}
}
public void stress6()
{
CircularQueue <int?> queue = new CircularQueue <int?>(5);
// start two getters and two putters and let 'em duke it out...
Thread t1 = new Thread(
delegate()
{
try
{
for (int i = 0; i < 100; i++)
{
Assert.IsTrue(queue.Put(i));
}
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e);
}
}
);
Thread t2 = new Thread(
delegate()
{
try
{
for (int i = 0; i < 100; i++)
{
Assert.IsTrue(queue.Put(i));
}
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e);
}
}
);
Thread t3 = new Thread(
delegate()
{
try
{
for (int i = 0; i < 100; i++)
{
Assert.IsNotNull(queue.Get());
}
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e);
}
}
);
Thread t4 = new Thread(
delegate()
{
try
{
for (int i = 0; i < 100; i++)
{
Assert.IsNotNull(queue.Get());
}
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e);
}
}
);
t1.Start();
t2.Start();
t3.Start();
t4.Start();
harvest(t1);
harvest(t2);
harvest(t3);
harvest(t4);
}
public void put()
{
CircularQueue <int?> queue = new CircularQueue <int?>();
queue.Put(null);
}
public void putget3()
{
CircularQueue <int?> queue = new CircularQueue <int?>();
Assert.IsTrue(queue.Put(1));
Assert.IsTrue(queue.Put(2));
Assert.IsTrue(queue.Put(3));
Assert.AreEqual(1, queue.Get());
Assert.AreEqual(2, queue.Get());
Assert.AreEqual(3, queue.Get());
Assert.IsTrue(queue.Put(1, 0));
Assert.IsTrue(queue.Put(2, 0));
Assert.IsTrue(queue.Put(3, 0));
Assert.AreEqual(1, queue.Get(0));
Assert.AreEqual(2, queue.Get(0));
Assert.AreEqual(3, queue.Get(0));
Assert.IsTrue(queue.Put(1, -1));
Assert.IsTrue(queue.Put(2, -1));
Assert.IsTrue(queue.Put(3, -1));
Assert.AreEqual(1, queue.Get(-1));
Assert.AreEqual(2, queue.Get(-1));
Assert.AreEqual(3, queue.Get(-1));
Assert.IsTrue(queue.Put(1, 1));
Assert.IsTrue(queue.Put(2, 1));
Assert.IsTrue(queue.Put(3, 1));
Assert.AreEqual(1, queue.Get(1));
Assert.AreEqual(2, queue.Get(1));
Assert.AreEqual(3, queue.Get(1));
}
