MessagePackObjectTest.Equals.Integer.tt

<#
//
// MessagePack for CLI
//
// Copyright (C) 2010-2012 FUJIWARA, Yusuke
//
//    Licensed 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.
//
#>
<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly Name="System.Core" #>
<#@ assembly Name="System.Numerics" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Numerics" #>
<#@ import namespace="System.Runtime.InteropServices" #>
<#

var __values =
	new object[]
	{
		Int64.MinValue,
		Int32.MinValue,
		Int16.MinValue,
		SByte.MinValue,
		( sbyte )-1,
		( byte )0,
		( byte )1,
		Byte.MaxValue,
		UInt16.MinValue,
		UInt32.MinValue,
		UInt64.MaxValue,
	};
	
var __numbers =
	new BigInteger[]
	{
		Int64.MinValue,
		Int32.MinValue,
		Int16.MinValue,
		SByte.MinValue,
		-1,
		0,
		1,
		Byte.MaxValue,
		UInt16.MinValue,
		UInt32.MinValue,
		UInt64.MaxValue,
	};

#>
#region -- License Terms --
//
// MessagePack for CLI
//
// Copyright (C) 2010-2012 FUJIWARA, Yusuke
//
//    Licensed 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.
//
#endregion -- License Terms --

using System;
#if !MSTEST
using NUnit.Framework;
#else
using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
using TimeoutAttribute = NUnit.Framework.TimeoutAttribute;
using Assert = NUnit.Framework.Assert;
using Is = NUnit.Framework.Is;
#endif

namespace MsgPack
{
	partial class MessagePackObjectTest_Equals
	{
<#
var __defined = new HashSet<string>();
for( int __i = 0; __i < __values.Length; __i++ )
{
	var __left = __numbers[ __i ];
	var __leftType = __values[ __i ].GetType();

	for( int __j = 0; __j < __values.Length; __j++ )
	{
		var __right = __numbers[ __j ];
		var __rightTypes = GetRightTypes( __right );
		foreach( var __rightType in __rightTypes )
		{
			var __methodName = "TestEquals_" + __leftType.Name + "0x" + __left.ToString( "x" ) + "_" + __rightType.Name + "0x" + __right.ToString( "x" ) + "_" + ( __left == __right );
			if( !__defined.Add( __methodName ) )
			{
				continue;
			}
#>
		[Test]
		public void <#= __methodName #>()
		{
			Assert<#= ( __left != __right ) ? "Not" : String.Empty #>Equals( ( <#= __leftType #> )( <#= __left #> ), ( <#= __rightType #> )( <#= __right #> ) );
		}
		
<#
		}
	}
}

foreach( var __leftType in __values.Select( x => x.GetType() ).Distinct() )
{
#>
		[Test]
		public void TestEquals<#= __leftType.Name #>_Nil_False()
		{
			AssertNotEquals( ( <#= __leftType #> )( 1 ), MessagePackObject.Nil );
		}

<#
	switch( __leftType.Name )
	{
		case "Int64":
		case "Int32":
		case "Int16":
		case "SByte":
		{
#>
		[Test]
		public void TestEquals<#= __leftType.Name #>MinusOne_Double_True()
		{
			AssertEquals( ( <#= __leftType #> )( -1 ), -1.0 );
		}

		[Test]
		public void TestEquals<#= __leftType.Name #>MinusOne_Single_True()
		{
			AssertEquals( ( <#= __leftType #> )( -1 ), -1.0f );
		}
<#
			break;
		}
	}
#>
		[Test]
		public void TestEquals<#= __leftType.Name #>Zero_Double_True()
		{
			AssertEquals( ( <#= __leftType #> )( 0 ), -0.0 );
		}

		[Test]
		public void TestEquals<#= __leftType.Name #>Zero_Single_True()
		{
			AssertEquals( ( <#= __leftType #> )( 0 ), -0.0f );
		}
		
		[Test]
		public void TestEquals<#= __leftType.Name #>PlusOne_Double_True()
		{
			AssertEquals( ( <#= __leftType #> )( 1 ), 1.0 );
		}

		[Test]
		public void TestEquals<#= __leftType.Name #>PlusOne_Single_True()
		{
			AssertEquals( ( <#= __leftType #> )( 1 ), 1.0f );
		}
		
<#
}
#>
	}
}
<#+
private static IEnumerable<Type> GetRightTypes( BigInteger right )
{
	if( Int64.MinValue <= right && right <= Int64.MaxValue )
	{
		yield return typeof( Int64 );
	}
	
	if( Int32.MinValue <= right && right <= Int32.MaxValue )
	{
		yield return typeof( Int32 );
	}
	
	if( Int16.MinValue <= right && right <= Int16.MaxValue )
	{
		yield return typeof( Int16 );
	}
	
	if( SByte.MinValue <= right && right <= SByte.MaxValue )
	{
		yield return typeof( SByte );
	}
	
	if( Byte.MinValue <= right && right <= Byte.MaxValue )
	{
		yield return typeof( Byte );
	}
	
	if( UInt16.MinValue <= right && right <= UInt16.MaxValue )
	{
		yield return typeof( UInt16 );
	}
	
	if( UInt32.MinValue <= right && right <= UInt32.MaxValue )
	{
		yield return typeof( UInt32 );
	}
	
	if( UInt64.MinValue <= right && right <= UInt64.MaxValue )
	{
		yield return typeof( UInt64 );
	}
}
#>