ByteArrayPackerTest.Allocation.tt

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly Name="System.Core" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Globalization" #>
<#@ import namespace="System.Linq" #>
<#

var patterns =
	new []
	{
		new { Label = "Fixed",		Single = "false",				RequiresAllocator = false,	CanAllocate = false },
		new { Label = "Default",	Single = "true",				RequiresAllocator = false,	CanAllocate = true },
		new { Label = "FixedSize",	Single = default( string ),		RequiresAllocator = false,	CanAllocate = true },
		new { Label = "Custom",		Single = "Reallocate",			RequiresAllocator = true,	CanAllocate = true },
	};

var variations =
	new []
	{
		new { Label = "Scalar",	Size = 9,	Input = "0x123456789AL",																		Output = "0xD3, 0, 0, 0, 0x12, 0x34, 0x56, 0x78, 0x9A" },
		new { Label = "Binary",	Size = 34,	Input = "Enumerable.Range( 0, 32 ).Select( x => ( byte )x ).ToArray()",							Output = "0xC4, 0x20, " + String.Join( ", ", Enumerable.Range( 0, 32 ).Select( x => "0x" + x.ToString( "X2" ) ) ) },
		new { Label = "String",	Size = 34,	Input = "new string( Enumerable.Range( ( int )'A', 32 ).Select( x => ( char )x ).ToArray() )",	Output = "0xD9, 0x20, " + String.Join( ", ", Enumerable.Range( ( int )'A', 32 ).Select( x => "0x" + x.ToString( "X2" ) ) ) },
	};

#>
#region -- License Terms --
//
// MessagePack for CLI
//
// Copyright (C) 2017 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;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
#if !MSTEST
using NUnit.Framework;
#else
using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
using TestCaseAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.DataRowAttribute;
using TimeoutAttribute = NUnit.Framework.TimeoutAttribute;
using Assert = NUnit.Framework.Assert;
using Is = NUnit.Framework.Is;
#endif

namespace MsgPack
{
	// This file was generated from ByteArrayPackerTest.Allocation.tt T4Template.
	// Do not modify this file. Edit ByteArrayPackerTest.Allocation.tt instead.

	partial class ByteArrayPackerTest
	{
		private const int DefaultAllocationSize = 65536;
		private const int FixedSizeAllocationSize = 8;
		private const int CustomAllocationSize = 16;
<#
foreach ( var isAsync in new [] { false, true } )
{
	if ( isAsync )
	{
#>

#if FEATURE_TAP
<#
	}

	// single
	foreach ( var pattern in patterns )
	{
		foreach ( var variation in variations )
		{
			this.PutSingleTest( pattern.Label + "_" + variation.Label + "_TooShortSize", pattern.RequiresAllocator, pattern.Single, 2, pattern.CanAllocate ? AllocationResult.Success : AllocationResult.Fail, variation.Input, variation.Output, isAsync, new [] { 0, 1 } );

			this.PutSingleTest( pattern.Label + "_" + variation.Label + "_EnoughSize", pattern.RequiresAllocator, pattern.Single, variation.Size, AllocationResult.None, variation.Input, variation.Output, isAsync, new [] { 0, 1 } );
		}
	}

	if ( isAsync )
	{
#>

#endif // FEATURE_TAP

<#
	}
}
#>
	}
}
<#+
private void PutSingleTest( string label, bool requiresAllocator, string allocation, int initialSize, AllocationResult allocationResult, string input, string output, bool isAsync, int[] offsets )
{
	if ( allocation == null )
	{
		// No case for this pattern.
		return;
	}
#>

		[Test]
<#+
	foreach ( var offset in offsets )
	{
#>
		[TestCase( <#= offset #> )]
<#+
	}
#>
		public <#= AsyncVoid( isAsync, allocationResult ) #> TestSingleAllocation_<#= label #><#= isAsync ? "Async" : String.Empty #>( int offset )
		{
<#+
	string allocationExpression;

	if ( requiresAllocator )
	{
#>
			var allocator = new Allocator();
<#+
			allocationExpression = "allocator." + allocation;
	}
	else
	{
			allocationExpression = allocation;
	}
#>
			var buffer = new byte[ <#= initialSize #> + offset ];
			using ( var target = CreatePacker( buffer, offset, <#= allocationExpression #> ) )
			{
				Assert.That( target.InitialBufferOffset, Is.EqualTo( offset ) );

<#+
	switch ( allocationResult )
	{
		case AllocationResult.None:
		case AllocationResult.Success:
		{
#>
				<#= Pack( "target", isAsync ) #>( <#= input #> );
				var expected = new byte[] { <#= output #> };
				Assert.That( target.BytesUsed, Is.EqualTo( expected.Length ) );

				var bytes = target.GetResultBytes();
				Assert.That( bytes.Offset, Is.EqualTo( target.InitialBufferOffset ) );
				Assert.That( bytes.Count, Is.EqualTo( target.BytesUsed ) );
<#+
			if ( allocationResult == AllocationResult.None )
			{
#>
				// Returns same array if buffer contains single array and its segment refers entire array.
				Assert.That( target.GetResultBytes().Array, Is.SameAs( bytes.Array ) );
				// Returns same array if no allocation has been ocurred.
				Assert.That( bytes.Array, Is.SameAs( buffer ) );

				// Returns same array if no allocation has been ocurred.
				Assert.That( target.GetFinalBuffer(), Is.SameAs( buffer ) );
<#+
			}
			else
			{
#>
				// Returns different array.
				Assert.That( bytes.Array, Is.Not.Null );
				Assert.That( bytes.Array, Is.Not.SameAs( buffer ) );

				Assert.That( target.GetFinalBuffer(), Is.Not.SameAs( buffer ) );
<#+
			}
#>

				// Only used contents are returned.
				Assert.That( bytes.ToArray(), Is.EqualTo( expected ) );
<#+
			break;
		}
		default:
		{
#>
				<#= Throws( isAsync ) #><InvalidOperationException>(
					<#= isAsync ? "async " : String.Empty #>() => <#= Pack( "target", isAsync ) #>( <#= input #> )
				);
<#+
			break;
		}
	}
#>
			}
<#+
	if ( requiresAllocator )
	{
#>
			Assert.That( allocator.IsOnly<#= allocation #>Called(), Is.<#= allocationResult == AllocationResult.Success #> );
<#+
	}
#>
		}
<#+
}

private static string AsyncVoid( bool isAsync, AllocationResult result )
{
	return ( isAsync && result != AllocationResult.Fail ) ? "async Task" : "void";
}

private static string Pack( string variable, bool isAsync )
{
	return ( isAsync ? "await " : String.Empty ) + variable + ".Pack" + ( isAsync ? "Async" : String.Empty );
}

private static string Throws( bool isAsync )
{
	return isAsync ? "AssertEx.ThrowsAsync" : "Assert.Throws";
}

private enum AllocationResult
{
	None,
	Success,
	Fail
}
#>