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

    }
}