// $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 Org.Apache.Etch.Bindings.Csharp.Msg;
using NUnit.Framework;

namespace Org.Apache.Etch.Bindings.Csharp.Support
{
    [TestFixture]
    public class TestValidator_Boolean
    {
        private readonly ValueFactory vf = new DummyValueFactory();

        [TestFixtureSetUp]
        public void First()
        {
            Console.WriteLine();
            Console.Write( "TestValidator_Boolean" );
        }

        [Test]
	    public void Constructor1()  
	    {
		    TestConstructor(0,"boolean[0]",typeof(Boolean));
            TestConstructor(1, "boolean[1]", typeof(Boolean[]));
            TestConstructor(2, "boolean[2]", typeof(Boolean[][]));
            TestConstructor(3, "boolean[3]", typeof(Boolean[][][]));
            TestConstructor(4, "boolean[4]", typeof(Boolean[][][][]));
            TestConstructor(5, "boolean[5]", typeof(Boolean[][][][][]));
            TestConstructor(6, "boolean[6]", typeof(Boolean[][][][][][]));
            TestConstructor(7, "boolean[7]", typeof(Boolean[][][][][][][]));
            TestConstructor(8, "boolean[8]", typeof(Boolean[][][][][][][][]));
            TestConstructor(9, "boolean[9]", typeof(Boolean[][][][][][][][][]));
            Assert.AreEqual(9,Validator.MAX_NDIMS);
	    }

        private void TestConstructor(int n, string descr, Type expectedClass)
        {
            Validator_boolean v = Validator_boolean.Get(n);
            Assert.AreEqual(n, v.GetNDims());
            Assert.AreSame(expectedClass,v.GetExpectedClass());
            Assert.AreEqual(descr, v.ToString());            
        }
 
	    [Test]
        [ExpectedException(typeof(ArgumentOutOfRangeException))]
	    public void Constructor2()
	    {		
		    Validator_boolean.Get( -1 );
	    }

        [Test]
        [ExpectedException(typeof(ArgumentOutOfRangeException))]
        public void Constructor3()
        {
            Validator_boolean.Get(Validator.MAX_NDIMS + 1);
        }

        [Test]
        public void ElementValidator1() 
	    {
		    TestElementValidator( 1, "boolean[0]", typeof(Boolean)  );
		    TestElementValidator( 2, "boolean[1]", typeof(Boolean[])  );
		    TestElementValidator( 3, "boolean[2]", typeof(Boolean[][])  );
		    TestElementValidator( 4, "boolean[3]", typeof(Boolean[][][])  );
		    TestElementValidator( 5, "boolean[4]", typeof(Boolean[][][][])  );
		    TestElementValidator( 6, "boolean[5]", typeof(Boolean[][][][][])  );
		    TestElementValidator( 7, "boolean[6]", typeof(Boolean[][][][][][])  );
		    TestElementValidator( 8, "boolean[7]", typeof(Boolean[][][][][][][])  );
		    TestElementValidator( 9, "boolean[8]", typeof(Boolean[][][][][][][][])  );
		    Assert.AreEqual( 9, Validator.MAX_NDIMS );
	    }

        private void TestElementValidator( int n, String descr, Type expectedClass )
	    {
		    Validator_boolean v = (Validator_boolean) Validator_boolean.Get( n ).ElementValidator();
		    Assert.AreEqual( n-1, v.GetNDims() );
		    Assert.AreSame( expectedClass, v.GetExpectedClass() );
		    Assert.AreEqual( descr, v.ToString() );
	    }


        [Test]
        [ExpectedException( typeof( ArgumentOutOfRangeException ) )]
	    public void ElementValidator2  ()
	    {		
		    Validator_boolean.Get( 0 ).ElementValidator();
        }

       
	    [Test]
	    public void Good_Scalar() 
	    {
		    TestGoodValue( 0,  false );
		    TestGoodValue( 0, true );
	    }
	
	
	    [Test]
	    public void Good_Array() 
	    {
		    TestGoodValue( 1, new Boolean[] {} );
		    TestGoodValue( 2,  new Boolean[][] {} );
		    TestGoodValue( 3,  new Boolean[][][] {} );
		    TestGoodValue( 4,  new Boolean[][][][] {} );
		    TestGoodValue( 5,  new Boolean[][][][][] {} );
		    TestGoodValue( 6,  new Boolean[][][][][][] {} );
		    TestGoodValue( 7,  new Boolean[][][][][][][] {} );
		    TestGoodValue( 8,  new Boolean[][][][][][][][] {} );
		    TestGoodValue( 9,  new Boolean[][][][][][][][][] {} );
		    Assert.AreEqual( 9, Validator.MAX_NDIMS );
	    }
	
	    private void TestGoodValue( int n,  Object value )
	    {
		    TypeValidator v = Validator_boolean.Get( n );
		   
		    Assert.IsTrue( v.Validate( value ) );
		    Assert.IsTrue( ValidateValueOk( v, value ) );
	    }
	
	
	    [Test]
	    public void bad_scalar() 
	    {
		    TestBadValue( 0, null );
		    TestBadValue( 0, (byte) 1 );
		    TestBadValue( 0, (short) 2222 );
		    TestBadValue( 0, 33333333 );
		    TestBadValue( 0, 4444444444444444L );
		    TestBadValue( 0, 5.5f );
		    TestBadValue( 0, 6.6 );
		    TestBadValue( 0, "" );
		    TestBadValue( 0, "abc" );
		    TestBadValue( 0, new Object() );
            TestBadValue(0, new StructValue(new XType("abc"), vf));
		    TestBadValue( 0, new DateTime() );

		    TestBadValue( 1, null );
		    TestBadValue( 1, false );
		    TestBadValue( 1, true );
		    TestBadValue( 1, (byte) 1 );
		    TestBadValue( 1, (short) 2222 );
		    TestBadValue( 1, 33333333 );
		    TestBadValue( 1, 4444444444444444L );
		    TestBadValue( 1, 5.5f );
		    TestBadValue( 1, 6.6 );
		    TestBadValue( 1, "" );
		    TestBadValue( 1, "abc" );
		    TestBadValue( 1, new Object() );
            TestBadValue(1, new StructValue(new XType("abc"), vf));
		    TestBadValue( 1, new DateTime() );
	    }
	
	
	    [Test]
	    public void bad_array() 
	    {
		    TestBadValue( 0, new Boolean[] {} );
		    TestBadValue( 1, new Boolean[][] {} );
		    TestBadValue( 2, new Boolean[][][] {} );
		    TestBadValue( 3, new Boolean[][][][] {} );
		    TestBadValue( 4, new Boolean[][][][][] {} );
		    TestBadValue( 5, new Boolean[][][][][][] {} );
		    TestBadValue( 6, new Boolean[][][][][][][] {} );
		    TestBadValue( 7, new Boolean[][][][][][][][] {} );
		    TestBadValue( 8, new Boolean[][][][][][][][][] {} );
		    TestBadValue( 9, new Boolean[][][][][][][][][][] {} );
		    Assert.AreEqual( 9, Validator.MAX_NDIMS );

		    TestBadValue( 2, new Boolean[] {} );
		    TestBadValue( 3, new Boolean[][] {} );
		    TestBadValue( 4, new Boolean[][][] {} );
		    TestBadValue( 5, new Boolean[][][][] {} );
		    TestBadValue( 6, new Boolean[][][][][] {} );
		    TestBadValue( 7, new Boolean[][][][][][] {} );
		    TestBadValue( 8, new Boolean[][][][][][][] {} );
		    TestBadValue( 9, new Boolean[][][][][][][][] {} );
            Assert.AreEqual(9, Validator.MAX_NDIMS);
	    }

	    private void TestBadValue( int n, Object value )
	    {
		    TypeValidator v = Validator_boolean.Get( n );
		    Assert.IsFalse( v.Validate( value ) );
		    Assert.IsFalse( ValidateValueOk( v, value ) );
	    }

	    private bool ValidateValueOk( Validator v, Object value )
	    {
		    try
		    {
			    Object x = v.ValidateValue( value );
			    Assert.AreEqual( value, x );
			    return true;
		    }
		    catch ( Exception )
		    {
               
                return false;
		    }
	    }


    }
}