// $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 );
	}

    }
}