| // $Id$ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| using System; |
| using System.Threading; |
| using NUnit.Framework; |
| |
| namespace Org.Apache.Etch.Bindings.Csharp.Util |
| { |
| internal delegate void run(); |
| |
| [TestFixture] |
| public class TestCircularQueue |
| { |
| |
| [TestFixtureSetUp] |
| public void First() |
| { |
| Console.WriteLine(); |
| Console.Write("TestCircularQueue"); |
| } |
| |
| [Test] |
| [ExpectedException( typeof( ArgumentOutOfRangeException ) )] |
| public void construct1() |
| { |
| new CircularQueue<int?>( 0 ); |
| } |
| |
| [Test] |
| [ExpectedException(typeof(ArgumentOutOfRangeException))] |
| public void construct2() |
| { |
| new CircularQueue<int?>( -1 ); |
| } |
| |
| |
| [Test] |
| public void construct3() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>( 1 ); |
| Assert.AreEqual( 1, queue.Size() ); |
| } |
| |
| |
| [Test] |
| public void construct4() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>( 2 ); |
| Assert.AreEqual( 2, queue.Size() ); |
| } |
| |
| |
| [Test] |
| public void construct5() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>(); |
| Assert.AreEqual( 10, queue.Size() ); |
| } |
| |
| |
| [Test] |
| 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() ); |
| } |
| } |
| |
| |
| [Test] |
| 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 ); */ |
| } |
| |
| |
| [Test] |
| 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 ) ); |
| } |
| |
| |
| [Test] |
| public void get() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>( 1 ); |
| |
| // System.nanoTime(); |
| HPTimer.Now(); |
| Assert.IsNull( queue.Get( 10 ) ); |
| assertRelError( 1, 1, 1 ); |
| |
| foreach (int i in new int[] { 10, 20, 30, 50, 80, 130, 210, 340, 550, 890, 1440 }) |
| { |
| // Console.WriteLine( "get delay = {0}\n", i ); |
| long t0 = HPTimer.Now(); |
| Assert.IsNull( queue.Get( i ) ); |
| /* double t = (HPTimer.Now() - t0) / 1000000.0; |
| assertRelError( i, t, 2 ); */ |
| } |
| } |
| |
| |
| [Test] |
| [ExpectedException(typeof(ArgumentNullException))] |
| public void put() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>(); |
| queue.Put( null ); |
| } |
| |
| |
| [Test] |
| 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 ) ); |
| } |
| |
| |
| [Test] |
| public void close1() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>(); |
| |
| Assert.IsFalse( queue.IsClosed() ); |
| queue.Close(); |
| Assert.IsTrue( queue.IsClosed() ); |
| |
| Assert.IsNull( queue.Get() ); |
| Assert.IsNull( queue.Get( -1 ) ); |
| Assert.IsNull( queue.Get( 0 ) ); |
| Assert.IsNull( queue.Get( 1 ) ); |
| |
| queue.Close(); |
| Assert.IsTrue( queue.IsClosed() ); |
| } |
| |
| |
| [Test] |
| 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() ); |
| } |
| |
| |
| [Test] |
| 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() ); |
| } |
| |
| |
| [Test] |
| 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() ); |
| } |
| |
| |
| [Test] |
| 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() ); |
| } |
| |
| |
| [Test] |
| public void stress1() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>( 1 ); |
| int n = 10000; |
| |
| 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++)
|
| Assert.AreEqual(i, queue.Get());
|
| }
|
|
|
| [Test]
|
| public void stress2()
|
| {
|
| CircularQueue<int?> queue = new CircularQueue<int?>(1);
|
| int n = 1000;
|
|
|
| Thread t = new Thread(
|
| delegate()
|
| {
|
| for (int i = 0; i < n; i++)
|
| {
|
| try
|
| {
|
| Thread.Sleep(5);
|
| queue.Put(i);
|
| }
|
| catch (ThreadInterruptedException e)
|
| {
|
| Console.WriteLine(e);
|
| }
|
| }
|
| }
|
| );
|
|
|
| t.Start();
|
|
|
| for (int i = 0; i < n; i++)
|
| Assert.AreEqual(i, queue.Get());
|
| }
|
|
|
|
|
| [Test]
|
| 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());
|
| }
|
| } |
| |
| [Test] |
| public void stress4() |
| { |
| CircularQueue<int?> queue = new CircularQueue<int?>(); |
| |
| // we will setup two threads waiting to get and |
| // then in a single synchronized step put two |
| // items in the queue. the first thread will be |
| // woken to get, and once done the second thread |
| // should be woken by the first. |
| |
| Thread t1 = new Thread( |
| delegate() |
| { |
| try |
| { |
| Assert.IsNotNull( queue.Get() ); |
| } |
| catch ( ThreadInterruptedException e ) |
| { |
| Console.WriteLine(e); |
| } |
| } |
| );
|
|
|
| Thread t2 = new Thread(
|
| delegate()
|
| {
|
| try
|
| {
|
| Assert.IsNotNull(queue.Get());
|
| }
|
| catch (ThreadInterruptedException e)
|
| {
|
| Console.WriteLine(e);
|
| }
|
| }
|
| );
|
|
|
| t1.Start();
|
| t2.Start();
|
|
|
| // wait until both threads are waiting on queue...
|
|
|
| Thread.Sleep(100);
|
|
|
| lock (queue)
|
| {
|
| queue.Put(1);
|
| queue.Put(2);
|
| }
|
|
|
| harvest(t1);
|
| harvest(t2);
|
| } |
| |
| |
| [Test] |
| 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);
|
| }
|
|
|
| [Test]
|
| 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);
|
| }
|
|
|
| [Test]
|
| public void harvest1()
|
| {
|
| Thread t = new Thread(
|
| delegate()
|
| {
|
| }
|
| );
|
| t.Start();
|
| harvest(t);
|
| }
|
|
|
| [Test]
|
| [ExpectedException(typeof(TimeoutException))]
|
| public void harvest2()
|
| {
|
| Thread t = new Thread(
|
| delegate()
|
| {
|
| try
|
| {
|
| Thread.Sleep(10000);
|
| }
|
| catch (ThreadInterruptedException e)
|
| {
|
| Console.WriteLine(e);
|
| }
|
| }
|
| );
|
| t.Start();
|
| harvest(t);
|
| }
|
|
|
| private void harvest(Thread t)
|
| {
|
| t.Join(1000);
|
| if (t.IsAlive)
|
| {
|
| t.Interrupt();
|
| throw new TimeoutException(t.Name + " is stuck");
|
| }
|
| }
|
|
|
|
|
| [Test]
|
| public void testRelError1()
|
| {
|
| assertRelError(10, 9, .11);
|
| assertRelError(10, 11, .14);
|
| assertRelError(20, 19, .07);
|
| assertRelError(19, 23, .22);
|
| }
|
|
|
|
|
| [Test]
|
| [ExpectedException(typeof(AssertionException))]
|
| public void testRelError2()
|
| {
|
| assertRelError(9, 8, .1);
|
| }
|
|
|
| [Test]
|
| [ExpectedException(typeof(AssertionException))]
|
| public void testRelError3()
|
| {
|
| assertRelError(9, 10, .1);
|
| }
|
|
|
| [Test]
|
| public void testAbsError1()
|
| {
|
| AssertAbsError(11, 15, 4);
|
| AssertAbsError(15, 10, 5);
|
| AssertAbsError(5, 3, 2);
|
| AssertAbsError(4, 7, 3);
|
| }
|
|
|
| [Test]
|
| [ExpectedException(typeof(AssertionException))]
|
| public void testAbsError2()
|
| {
|
| AssertAbsError(11, 15, 3);
|
| }
|
|
|
| [Test]
|
| [ExpectedException(typeof(AssertionException))]
|
| public void testAbsError3()
|
| {
|
| AssertAbsError(19, 15, 3);
|
| } |
| |
| private void Delay( int delay, run del ) |
| { |
| |
| Thread t = new Thread(delegate() |
| { |
| try |
| { |
| Thread.Sleep(delay); |
| del(); |
| } |
| catch (Exception e) |
| { |
| Console.WriteLine(e); |
| } |
| }); |
| t.Start(); |
| } |
| |
| private void assertRelError( double expected, double actual, double error ) |
| { |
| double relError = RelError( expected, actual ); |
| if (relError > error) |
| Assert.Fail( String.Format( "expected: {0} but was: {1} relative error: {2}", expected, actual, relError ) ); |
| } |
| |
| private void AssertAbsError( double expected, double actual, double error ) |
| { |
| double absError = AbsError( expected, actual ); |
| if (absError > error) |
| |
| Assert.Fail( String.Format( "expected: {0} but was: {1} absolute error: {2}", expected, actual, absError ) ); |
| } |
| |
| private double RelError( double expected, double actual ) |
| { |
| return AbsError( expected, actual ) / expected; |
| } |
| |
| private double AbsError( double expected, double actual ) |
| { |
| return Math.Abs( expected - actual ); |
| } |
| |
| } |
| } |
