// $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_byte
    {
        private readonly ValueFactory vf = new DummyValueFactory();

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

        [Test]
        public void Contructor1()
        {
      
            testconstructor( 0, "byte[0]", typeof(sbyte) );
		    testconstructor( 1, "byte[1]", typeof( sbyte[]) );
		    testconstructor( 2, "byte[2]", typeof( sbyte[][] ) );
		    testconstructor( 3, "byte[3]", typeof( sbyte[][][] ) );
		    testconstructor( 4, "byte[4]", typeof( sbyte[][][][] ) );
		    testconstructor( 5, "byte[5]", typeof( sbyte[][][][][] ) );
		    testconstructor( 6, "byte[6]", typeof( sbyte[][][][][][] ) );
		    testconstructor( 7, "byte[7]", typeof( sbyte[][][][][][][] ) );
		    testconstructor( 8, "byte[8]", typeof( sbyte[][][][][][][][] ) );
            testconstructor(9, "byte[9]", typeof(sbyte[][][][][][][][][]));
		    Assert.AreEqual( 9, Validator.MAX_NDIMS );
            
        }

        private void testconstructor( int n, String descr, Type expectedClass )
	    {
		    TypeValidator v = Validator_byte.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_byte.Get( -1 );
	    }
	
	
	    [Test] 
        [ExpectedException( typeof( ArgumentOutOfRangeException ) )]
	    public void constructor3() 
	    {
		    Validator_byte.Get( Validator.MAX_NDIMS+1 );
	    }
	
	
	    [Test]
	    public void elementvalidator1() 
	    {
		    testelementvalidator( 1, "byte[0]", typeof(sbyte) );
		    testelementvalidator( 2, "byte[1]", typeof( sbyte[]) );
		    testelementvalidator( 3, "byte[2]", typeof( sbyte[][] ) );
		    testelementvalidator( 4, "byte[3]", typeof( sbyte[][][] ) );
		    testelementvalidator( 5, "byte[4]", typeof( sbyte[][][][] ) );
		    testelementvalidator( 6, "byte[5]", typeof( sbyte[][][][][] ) );
		    testelementvalidator( 7, "byte[6]", typeof( sbyte[][][][][][] ) );
		    testelementvalidator( 8, "byte[7]", typeof( sbyte[][][][][][][] ) );
		    testelementvalidator( 9, "byte[8]", typeof( sbyte[][][][][][][][] ) );
           
		    Assert.AreEqual( 9, Validator.MAX_NDIMS );
	    }
	
	    private void testelementvalidator( int n, String descr, Type expectedClass )
	    {
		    TypeValidator v = (TypeValidator) Validator_byte.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_byte.Get( 0 ).ElementValidator();
	    }
	
	
	    [Test]
	    public void good_scalar() 
	    {
		    // BYTES
    		
		    testgoodvalue( 0,  (sbyte) 0 );
    		
		    testgoodvalue( 0,  (sbyte) 1 );
		    testgoodvalue( 0,  (sbyte) 64 );
		    testgoodvalue( 0,  SByte.MaxValue );
    		
		    testgoodvalue( 0,  (sbyte) -1 );
		    testgoodvalue( 0,  (sbyte) -64 );
		    testgoodvalue( 0,  SByte.MinValue );

		    // SHORTS
    		
		    testgoodvalue( 0,  (short) 0 );
    		
		    testgoodvalue( 0,  (short) 1 );
		    testgoodvalue( 0,  (short) 64 );
		    testgoodvalue( 0,  (short) SByte.MaxValue );
    		
		    testgoodvalue( 0,  (short) -1 );
		    testgoodvalue( 0,  (short) -64 );
		    testgoodvalue( 0,  (short) SByte.MinValue );

		    // INTS
    		
		    testgoodvalue( 0,  0 );
    		
		    testgoodvalue( 0,  1 );
		    testgoodvalue( 0,  64 );
		    testgoodvalue( 0,  (int) SByte.MaxValue );
    		
		    testgoodvalue( 0,  -1 );
		    testgoodvalue( 0,  -64 );
		    testgoodvalue( 0,  (int) SByte.MinValue );

		    // LONGS
    		
		    testgoodvalue( 0,  (long) 0 );
    		
		    testgoodvalue( 0,  (long) 1 );
		    testgoodvalue( 0,  (long) 64 );
		    testgoodvalue( 0,  (long) SByte.MaxValue );
    		
		    testgoodvalue( 0,  (long) -1 );
		    testgoodvalue( 0,  (long) -64 );
		    testgoodvalue( 0,  (long) SByte.MinValue );
	    }
	
	
	    [Test]
	    public void good_array() 
	    {
		    testgoodvalue( 1,new sbyte[] {} );
		    testgoodvalue( 2,  new sbyte[][] {} );
		    testgoodvalue( 3,  new sbyte[][][] {} );
		    testgoodvalue( 4,  new sbyte[][][][] {} );
		    testgoodvalue( 5,  new sbyte[][][][][] {} );
		    testgoodvalue( 6,  new sbyte[][][][][][] {} );
		    testgoodvalue( 7,  new sbyte[][][][][][][] {} );
		    testgoodvalue( 8,  new sbyte[][][][][][][][] {} );
		    testgoodvalue( 9,  new sbyte[][][][][][][][][] {} );
		    Assert.AreEqual( 9, Validator.MAX_NDIMS );
	    }
	
	    private void testgoodvalue( int n,Object value )
	    {
		    TypeValidator v = Validator_byte.Get( n );
		    Assert.IsTrue( v.Validate( value ) );
		    Assert.IsTrue( ValidateValueOk( v, value ) );
	    }
	
	    
	    [Test]
	    public void bad_scalar() 
	    {
		    testbadvalue( 0, null );
		    testbadvalue( 0, false );
		    testbadvalue( 0, true );
    //		testbadvalue( 0, (byte) 1 ); good!
		    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, 333333 );
		    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 sbyte[] {} );
		    testbadvalue( 1, new sbyte[][] {} );
		    testbadvalue( 2, new sbyte[][][] {} );
		    testbadvalue( 3, new sbyte[][][][] {} );
		    testbadvalue( 4, new sbyte[][][][][] {} );
		    testbadvalue( 5, new sbyte[][][][][][] {} );
		    testbadvalue( 6, new sbyte[][][][][][][] {} );
		    testbadvalue( 7, new sbyte[][][][][][][][] {} );
		    testbadvalue( 8, new sbyte[][][][][][][][][] {} );
		    testbadvalue( 9, new sbyte[][][][][][][][][][] {} );
		    Assert.AreEqual( 9, Validator.MAX_NDIMS );

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

	    private void testbadvalue( int n, Object value )
	    {
	        TypeValidator v = Validator_byte.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;
		    }
	    }

      
    }
}