// $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 Etch4.Util.Test;
using NUnit.Framework;

namespace Org.Apache.Etch.Bindings.Csharp.Util
{
    [TestFixture]
    public class TestMonitor
    {
        private const double REL_ERROR = 100000;
	
	/** @ */
	[Test]
	public void construct1() 
	{
		testconstruct1( null );
		testconstruct1( "a" );
		testconstruct1( "b" );
	}
	
	private void testconstruct1( String descr )
	{
		Monitor<Object> m = new Monitor<Object>( descr );
		Assert.AreEqual( descr, m.GetDescription() );
		Assert.IsNull( m.Get() );
	}

	/** @ */
	[Test]
	public void construct2() 
	{
		testconstruct2( null, null );
		testconstruct2( null, true );
		testconstruct2( null, 1 );
		testconstruct2( null, "abc" );
		testconstruct2( null, 3.14159 );
		
		testconstruct2( "a", null );
		testconstruct2( "b", true );
		testconstruct2( "c", 1 );
		testconstruct2( "d", "abc" );
		testconstruct2( "e", 3.14159 );
	}
	
	private void testconstruct2( String descr, Object value )
	{
		Monitor<Object> m = new Monitor<Object>( descr, value );
		Assert.AreEqual( descr, m.GetDescription() );
		Assert.AreEqual( value, m.Get() );
	}
	
	/** @ */
	[Test]
	public void mToString() 
	{
        Assert.AreEqual("Monitor : ", new Monitor<Object>(null, null).ToString());
		Assert.AreEqual( "Monitor : True", new Monitor<Object>( null, true ).ToString() );
		Assert.AreEqual( "Monitor : 1", new Monitor<Object>( null, 1 ).ToString() );
		Assert.AreEqual( "Monitor : abc", new Monitor<Object>( null, "abc" ).ToString() );
		Assert.AreEqual( "Monitor : 3.14159", new Monitor<Object>( null, 3.14159 ).ToString() );

		Assert.AreEqual( "Monitor a: ", new Monitor<Object>( "a", null ).ToString() );
		Assert.AreEqual( "Monitor b: True", new Monitor<Object>( "b", true ).ToString() );
		Assert.AreEqual( "Monitor c: 1", new Monitor<Object>( "c", 1 ).ToString() );
		Assert.AreEqual( "Monitor d: abc", new Monitor<Object>( "d", "abc" ).ToString() );
		Assert.AreEqual( "Monitor e: 3.14159", new Monitor<Object>( "e", 3.14159 ).ToString() );
	}
	
	/** @ */
	[Test]
	public void Set1() 
	{
		Monitor<Object> m = new Monitor<Object>( "a", null );
		Assert.AreEqual( null, m.Set( 1 ) );
		Assert.AreEqual( 1, m.Set( 2 ) );
		Assert.AreEqual( 2, m.Set( null ) );
		Assert.AreEqual( null, m.Set( null ) );
	}
	
	/** @ */
	[Test]
	public void Set2() 
	{
		Monitor<Object> m = new Monitor<Object>( "a", 1 );
		Assert.AreEqual( 1, m.Set( 2 ) );
		Assert.AreEqual( 2, m.Set( null ) );
		Assert.AreEqual( null, m.Set( null ) );
	}
	
	/** @ */
	[Test]
	public void SetGet() 
	{
		Monitor<Object> m = new Monitor<Object>( "a", 1 );
		
		Assert.AreEqual( 1, m.Set( 2 ) );
		Assert.AreEqual( 2, m.Get() );
		
		Assert.AreEqual( 2, m.Set( null ) );
		Assert.AreEqual( null, m.Get() );
		
		Assert.AreEqual( null, m.Set( null ) );
		Assert.AreEqual( null, m.Get() );
	}
	
	/** @ */
        [Ignore]
	[Test]
	public void Setsync() 
	{
		 Monitor<int?> m = new Monitor<int?>( "a", null );
		 bool[] flag = new bool[2000];

        Thread t = new Thread(new ThreadStart( delegate()
                                                   {
                                                       for (int i = 0; i < 1000; i++)
				{
					int? x = m.Set( i );
					
						flag[x.GetValueOrDefault()] = true;
				}
                                                   }));

	    Thread t1 = TestHelp.Delay(1000, t);


	    Thread t2 = TestHelp.Delay(1000, new Thread(new ThreadStart(delegate()
	                     {
                          for (int i = 1000; i < 2000; i++)
				         {
					            int? x = m.Set( i );					
						        flag[x.GetValueOrDefault()] = true;
				         }
	                                                                     
	                     }
                         )));
		

		t1.Start();
		t2.Start();
		
		t1.Join();
		t2.Join();
		
		int? x1 = m.Set( null );
		
			flag[x1.GetValueOrDefault()] = true;
		
		foreach (bool b  in flag)
			Assert.IsTrue( b );
	}
	
	/** @ */
	[Test]
	public void waitUntilEq1() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		m.WaitUntilEq( null );
		m.WaitUntilEq( null, 0 );
		
		m.Set( 1 );
		m.WaitUntilEq( 1 );
		m.WaitUntilEq( 1, 0 );
		
		m.Set( 2 );
		m.WaitUntilEq( 2 );
		m.WaitUntilEq( 2, 0 );
	}
	
	/** @ */
	[Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilEq2() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", 1 );
		m.WaitUntilEq( 2, 1 );
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilEq3() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		m.WaitUntilEq( 2, 1 );
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilEq4() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", 1 );
		m.WaitUntilEq( null, 1 );
	}
	
	/** @ */
	[Test]
	public void waitUntilNotEq1() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		m.WaitUntilNotEq( 1 );
		m.WaitUntilNotEq( 1, 0 );
		
		m.Set( 1 );
		m.WaitUntilNotEq( null );
		m.WaitUntilNotEq( null, 0 );
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilNotEq2() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		m.WaitUntilNotEq( null, 1 );
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilNotEq3() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", 1 );
		m.WaitUntilNotEq( 1, 1 );
	}
	
	/** @ */
	[Test]
	public void waitUntilEqAndSet1() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		Assert.AreEqual( null, m.WaitUntilEqAndSet( null, 1 ) );
		Assert.AreEqual( 1, m.WaitUntilEqAndSet( 1, 2 ) );
		Assert.AreEqual( 2, m.WaitUntilEqAndSet( 2, null ) );
		Assert.AreEqual( null, m.WaitUntilEqAndSet( null, null ) );

		Assert.AreEqual( null, m.WaitUntilEqAndSet( null, 0, 1 ) );
		Assert.AreEqual( 1, m.WaitUntilEqAndSet( 1, 0, 2 ) );
		Assert.AreEqual( 2, m.WaitUntilEqAndSet( 2, 0, null ) );
		Assert.AreEqual( null, m.WaitUntilEqAndSet( null, 0, null ) );
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilEqAndSet2() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		try
		{
			m.WaitUntilEqAndSet( 1, 1, 2 );
		}
		finally
		{
			Assert.AreEqual( null, m.Get() );
		}
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilEqAndSet3() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", 1 );
		try
		{
			m.WaitUntilEqAndSet( null, 1, 2 );
		}
		finally
		{
			Assert.AreEqual( 1, m.Get() );
		}
	}
	
	/** @ */
	[Test]
	public void waitUntilNotEqAndSet1() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		Assert.AreEqual( null, m.WaitUntilNotEqAndSet( 2, 1 ) );
		Assert.AreEqual( 1, m.WaitUntilNotEqAndSet( 3, 2 ) );
		Assert.AreEqual( 2, m.WaitUntilNotEqAndSet( 4, null ) );
		Assert.AreEqual( null, m.WaitUntilNotEqAndSet( 5, null ) );

		Assert.AreEqual( null, m.WaitUntilNotEqAndSet( 2, 0, 1 ) );
		Assert.AreEqual( 1, m.WaitUntilNotEqAndSet( 3, 0, 2 ) );
		Assert.AreEqual( 2, m.WaitUntilNotEqAndSet( 4, 0, null ) );
		Assert.AreEqual( null, m.WaitUntilNotEqAndSet( 5, 0, null ) );
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilNotEqAndSet2() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		try
		{
			m.WaitUntilNotEqAndSet( null, 1, 1 );
		}
		finally
		{
			Assert.AreEqual( null, m.Get() );
		}
	}
	
	/** @ */
        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
	public void waitUntilNotEqAndSet3() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", 1 );
		try
		{
			m.WaitUntilNotEqAndSet( 1, 1, null );
		}
		finally
		{
			Assert.AreEqual( 1, m.Get() );
		}
	}
	
	/** @ */
	[Test]
	public void waitUntilEq5() 
	{
	    Monitor<int?> m = new Monitor<int?>( "a", null );
		
		Thread t = TestHelp.delayAndStart( 200, new Thread(new ThreadStart(delegate()
		                                                                       {
		                                                                          m.Set( 1 ); 
		                                                                       })));


	    long t0 = HPTimer.Now();
		m.WaitUntilEq( 1 );
		double t1 = (HPTimer.Now() - t0) / 1000000.0;
		TestHelp.AssertRelError( 200, t1, REL_ERROR );
		
		t.Join();
	}
	
	/** @ */
	[Test]
	public void waitUntilNotEq4() 
	{
		   Monitor<int?> m = new Monitor<int?>( "a", null );
		
		Thread t = TestHelp.delayAndStart( 200, new Thread(new ThreadStart(delegate()
		                                                                       {
		                                                                          m.Set( 1 ); 
		                                                                       })));


		long t0 = HPTimer.Now();
		m.WaitUntilNotEq( null );
		double t1 = (HPTimer.Now() - t0) / 1000000.0;
		TestHelp.AssertRelError( 200, t1, REL_ERROR );
		
		t.Join();
	}
	
	/** @ */
	[Test]
	public void waitUntilEqAndSet4() 
	{
		Monitor<int?> m = new Monitor<int?>( "a", null );
		
		Thread t = TestHelp.delayAndStart( 200, new Thread(new ThreadStart(delegate()
		                                                                       {
		                                                                          m.Set( 1 ); 
		                                                                       })));

	    long t0 = HPTimer.Now();
		m.WaitUntilEqAndSet( 1, 2 );
		double t1 = (HPTimer.Now() - t0) / 1000000.0;
		// TODO is there a better way for choosing relative error?
		TestHelp.AssertRelError( 200, t1, REL_ERROR );
		
		t.Join();
	}
	
	/** @ */
	[Test]
	public void waitUntilNotEqAndSet4() 
	{
        Monitor<int?> m = new Monitor<int?>("a", null);

        Thread t = TestHelp.delayAndStart(200, new Thread(new ThreadStart(delegate()
                                                                               {
                                                                                   m.Set(1);
                                                                               })));

	    long t0 = HPTimer.Now();
		m.WaitUntilNotEqAndSet( null, 2 );
        double t1 = (HPTimer.Now() - t0) / 1000000.0;
		TestHelp.AssertRelError( 200, t1, REL_ERROR );
		
		t.Join();
	}

    }
}