AutoMessagePackSerializerTest.ttinclude

<#@include file="AutoMessagePackSerializerTest.Polymorphism.ttinclude" #>
<#+ 
void Geneate( string serializationMethod, string emitterFlavor, string builderTypeName, bool canDump, string language = "" )
{
	GenerateCore( serializationMethod, emitterFlavor, builderTypeName, language, canDump, false );
}

void GeneateForIos( string serializationMethod )
{
	GenerateCore( serializationMethod, "GenerationBased", null, String.Empty, false, true );
}

private void GenerateCore( string serializationMethod, string emitterFlavor, string builderTypeName, string language, bool canDump, bool forIos )
{
	var testClassName = serializationMethod + language + emitterFlavor + ( String.IsNullOrWhiteSpace( builderTypeName ) ? "Reflection" : "Auto" ) + "MessagePackSerializerTest";

	var constructorParamterSpecs =
		new []
		{
			new KeyValuePair<string, string>( "Byte", "( byte )2" ),
			new KeyValuePair<string, string>( "SByte", "( sbyte )-2" ),
			new KeyValuePair<string, string>( "Int16", "( short )-2" ),
			new KeyValuePair<string, string>( "UInt16", "( ushort )2" ),
			new KeyValuePair<string, string>( "Int32", "-2" ),
			new KeyValuePair<string, string>( "UInt32", "( uint )2" ),
			new KeyValuePair<string, string>( "Int64", "-2L" ),
			new KeyValuePair<string, string>( "UInt64", "( ulong )2L" ),
			new KeyValuePair<string, string>( "Single", "1.2f" ),
			new KeyValuePair<string, string>( "Double", "1.2" ),
			new KeyValuePair<string, string>( "Decimal", "1.2m" ),
			new KeyValuePair<string, string>( "Boolean", "true" ),
			new KeyValuePair<string, string>( "Char", "'A'" ),
			new KeyValuePair<string, string>( "String", "\"ABC\"" ),
		};
#>
#region -- License Terms --
//
// MessagePack for CLI
//
// Copyright (C) 2010-2017 FUJIWARA, Yusuke and contributors
//
//    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.
//
// Contributors:
//    Samuel Cragg
//
#endregion -- License Terms --

#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
#define UNITY
#endif

#pragma warning disable 3003
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Linq;
#if !NET35 && !WINDOWS_PHONE
using System.Numerics;
#endif // !NET35 && !WINDOWS_PHONE
using System.Reflection;
#if !SILVERLIGHT
using System.Runtime.InteropServices.ComTypes;
#endif // !SILVERLIGHT
using System.Runtime.Serialization;
using System.Text;
<#+
if ( serializationMethod == "Map" && !forIos )
{
#>
using System.Text.RegularExpressions;
<#+
}
#>
#if FEATURE_TAP
using System.Threading;
using System.Threading.Tasks;
#endif // FEATURE_TAP
#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN
using MsgPack.Serialization.CodeDomSerializers;
#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN
#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1
using MsgPack.Serialization.EmittingSerializers;
#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1
#if SILVERLIGHT
// For DateTime.ToBinary() extension method
using MsgPack.Serialization.DefaultSerializers;
#endif // SILVERLIGHT
#if !MSTEST
using NUnit.Framework;
#else
using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
using SetUpAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestInitializeAttribute;
using TearDownAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestCleanupAttribute;
using TimeoutAttribute = NUnit.Framework.TimeoutAttribute;
using CategoryAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestCategoryAttribute;
using Assert = NUnit.Framework.Assert;
using Is = NUnit.Framework.Is;
using Does = NUnit.Framework.Does;
#endif

namespace MsgPack.Serialization
{
	[TestFixture]
	[Timeout( 60000 )]
	public class <#= testClassName #>
	{
		private static SerializationContext GetSerializationContext()
		{
<#+
	if ( !forIos )
	{
#>
			var context = new SerializationContext { SerializationMethod = SerializationMethod.<#= serializationMethod #> };
			context.SerializerOptions.EmitterFlavor = EmitterFlavor.<#=  emitterFlavor #>;
#if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
			context.SerializerOptions.DisablePrivilegedAccess = true;
#endif // SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
			return context;
<#+
	}
	else
	{
#>
			var context = PreGeneratedSerializerActivator.CreateContext( SerializationMethod.<#= serializationMethod #>, SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions );
			// Register serializers for abstract class testing
			context.Serializers.Register( 
				new EchoKeyedCollection_2MessagePackSerializer<string, string>( context, null ) 
			);
			return context;
<#+
	}
#>
		}

		private static SerializationContext NewSerializationContext()
		{
			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
		}

		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
		{
<#+
	if ( !forIos )
	{
#>
			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
			context.SerializationMethod = SerializationMethod.<#= serializationMethod #>;
			context.SerializerOptions.EmitterFlavor = EmitterFlavor.<#= emitterFlavor #>;
#if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
			context.SerializerOptions.DisablePrivilegedAccess = true;
#endif // SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
			return context;
<#+
	}
	else
	{
#>
			var context =  PreGeneratedSerializerActivator.CreateContext( SerializationMethod.Array, compatibilityLevel );
			// Register serializers for abstract class testing
			context.Serializers.Register( 
				new EchoKeyedCollection_2MessagePackSerializer<string, string>( context, null ) 
			);
			return context;
<#+
	}
#>
		}

		private MessagePackSerializer<T> CreateTarget<T>( SerializationContext context )
		{
			return context.GetSerializer<T>( context );
		}

#if UNITY
		[TestFixtureSetUp]
		public static void SetUpFixture()
		{
			MessagePackSerializer.PrepareCollectionType<byte>();
			MessagePackSerializer.PrepareCollectionType<char>();
			MessagePackSerializer.PrepareCollectionType<int>();
			MessagePackSerializer.PrepareCollectionType<decimal>();
			MessagePackSerializer.PrepareDictionaryType<string, int>();
			MessagePackSerializer.PrepareDictionaryType<int, int>();
			MessagePackSerializer.PrepareDictionaryType<string, DateTimeOffset>();
			MessagePackSerializer.PrepareType<System.Diagnostics.TraceOptions>();
			new ArraySegmentEqualityComparer<byte>().Equals( default( ArraySegment<byte> ), default( ArraySegment<byte> ) );
			new ArraySegmentEqualityComparer<char>().Equals( default( ArraySegment<char> ), default( ArraySegment<char> ) );
			new ArraySegmentEqualityComparer<int>().Equals( default( ArraySegment<int> ), default( ArraySegment<int> ) );
			new ArraySegmentEqualityComparer<decimal>().Equals( default( ArraySegment<decimal> ), default( ArraySegment<decimal> ) );
		}
#endif // UNITY
		
<#+
	if ( !forIos )
	{
#>
		private bool CanDump
		{
			get { return <#= canDump.ToString().ToLowerInvariant() #>; }
		}

#if !SILVERLIGHT && !AOT && !XAMARIN
		[SetUp]
		public void SetUp()
		{
<#+
		if ( emitterFlavor == "ExpressionBased" )
		{
#>
#warning TODO: true async
			SerializerDebugging.IsNaiveAsyncAllowed = true;
<#+
		}
#>

#if !NETSTANDARD1_1 && !NETSTANDARD1_3
			//SerializerDebugging.TraceEnabled = true;
			//SerializerDebugging.DumpEnabled = true;
			if ( SerializerDebugging.TraceEnabled )
			{
				Tracer.Emit.Listeners.Clear();
				Tracer.Emit.Switch.Level = SourceLevels.All;
#if NETSTANDARD2_0
				Tracer.Emit.Listeners.Add( new TextWriterTraceListener( Console.Out ) );
#else // NETSTANDRD2_0
				Tracer.Emit.Listeners.Add( new ConsoleTraceListener() );
#endif // NETSTANDRD2_0
			}

			SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory );
			SerializerDebugging.DeletePastTemporaries();
			SerializerDebugging.OnTheFlyCodeGenerationEnabled = true;

#if NET35
			SerializerDebugging.SetCodeCompiler( CodeDomCodeGeneration.Compile );
#else
			SerializerDebugging.SetCodeCompiler( RoslynCodeGeneration.Compile );
#endif // NET35

			SerializerDebugging.DumpDirectory = TestContext.CurrentContext.TestDirectory;
			SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location );
			if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly )
			{
				SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location );
			}
#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
		}

		[TearDown]
		public void TearDown()
		{
#if !NETSTANDARD1_1 && !NETSTANDARD1_3

			if ( SerializerDebugging.DumpEnabled && this.CanDump )
			{
#if !NETSTANDARD2_0
				try
				{
					SerializerDebugging.Dump();
				}
				catch ( NotSupportedException ex )
				{
					Console.Error.WriteLine( ex );
				}
				finally
				{
					SerializationMethodGeneratorManager.Refresh();
				}
#else // !NETSTANDARD2_0
				SerializationMethodGeneratorManager.Refresh();
#endif // !NETSTANDARD2_0
			}

			SerializerDebugging.Reset();
			SerializerDebugging.OnTheFlyCodeGenerationEnabled = false;
#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
		}
#endif // !SILVERLIGHT && !AOT && !XAMARIN
<#+
	} // if !forIos
#>

		private void DoKnownCollectionTest<T>( SerializationContext context )
			where T : new()
		{
			using ( var buffer = new MemoryStream() )
			{
				CreateTarget<T>( context ).Pack( buffer, new T() );
			}
		}

		[Test]
		public void TestUnpackTo()
		{
			var target = this.CreateTarget<Int32[]>( GetSerializationContext() );
			using ( var buffer = new MemoryStream() )
			{
				target.Pack( buffer, new[] { 1, 2 } );
				buffer.Position = 0;
				int[] result = new int[ 2 ];
				using ( var unpacker = Unpacker.Create( buffer, false ) )
				{
					unpacker.Read();
					target.UnpackTo( unpacker, result );
					Assert.That( result, Is.EqualTo( new[] { 1, 2 } ) );
				}
			}
		}

		[Test]
		public void TestInt32()
		{
			TestCore( 1, stream => Unpacking.UnpackInt32( stream ), null );
		}

		[Test]
		public void TestInt64()
		{
			TestCore( Int32.MaxValue + 1L, stream => Unpacking.UnpackInt64( stream ), null );
		}

		[Test]
		public void TestString()
		{
			TestCore( "abc", stream => Unpacking.UnpackString( stream ), null );
		}

		[Test]
		public void TestDateTime()
		{
			TestCore(
				DateTime.UtcNow,
				stream => MessagePackSerializer.UnpackMessagePackObject( stream ).AsTimestamp().ToDateTime(),
				( x, y ) => x.Equals( y ),
				context =>
				{
					Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Timestamp ) );
				}
			);
		}

		[Test]
		public void TestDateTimeOffset()
		{
			TestCore(
				DateTimeOffset.UtcNow,
				stream => MessagePackSerializer.UnpackMessagePackObject( stream ).AsTimestamp().ToDateTimeOffset(),
				( x, y ) => x.Equals( y ),
				context =>
				{
					Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Timestamp ) );
				}
			);
		}

		[Test]
		public void TestDateTimeLatest()
		{
			TestCore(
				DateTime.UtcNow,
				stream => Timestamp.Decode( Unpacking.UnpackExtendedTypeObject( stream ) ).ToDateTime(),
				( x, y ) => x.Equals( y ),
				context =>
				{
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Timestamp;
				}
			);
		}

		[Test]
		public void TestDateTimeOffsetLatest()
		{
			TestCore(
				DateTimeOffset.UtcNow,
				stream => Timestamp.Decode( Unpacking.UnpackExtendedTypeObject( stream ) ).ToDateTimeOffset(),
				( x, y ) => x.Equals( y ),
				context =>
				{
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Timestamp;
				}
			);
		}

		[Test]
		public void TestDateTimeClassic0_9()
		{
			TestCore(
				DateTime.Now, // Use now because Native mode should serialize its kind
				stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ),
				( x, y ) => x.Equals( y ),
				context =>
				{
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native;
				}
			);
		}

		[Test]
		public void TestDateTimeOffsetClassic0_9()
		{
			TestCore(
				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
				stream => 
					{
						var array = Unpacking.UnpackArray( stream );
						return new DateTimeOffset( DateTime.FromBinary( array[ 0 ].AsInt64() ), TimeSpan.FromMinutes( array[ 1 ].AsInt16() ) );
					},
				( x, y ) => x.Equals( y ),
				context =>
				{
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native;
				}
			);
		}

		[Test]
		public void TestDateTimeClassic0_5()
		{
			TestCore(
				DateTime.UtcNow,
				stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ),
				CompareDateTime,
				context =>
				{
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc;
				}
			);
		}

		[Test]
		public void TestDateTimeOffsetClassic0_5()
		{
			TestCore(
				DateTimeOffset.UtcNow,
				stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ),
				CompareDateTime,
				context =>
				{
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc;
				}
			);
		}
		
		[Test]
		public void TestDateTimeNullableChangeOnDemand()
		{
			TestCore(
				( DateTime? )DateTime.UtcNow,
				stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ),
				CompareDateTime,
				context =>
				{
					context.GetSerializer<DateTime?>();
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc;
				}
			);
		}

		[Test]
		public void TestDateTimeOffsetNullableChangeOnDemand()
		{
			TestCore(
				( DateTimeOffset? )DateTimeOffset.UtcNow,
				stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ),
				CompareDateTime,
				context =>
				{
					context.GetSerializer<DateTimeOffset?>();
					context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc;
				}
			);
		}

		private static bool CompareDateTime( DateTime x, DateTime y )
		{
			return x.Date == y.Date && x.Hour == y.Hour && x.Minute == y.Minute && x.Second == y.Second && x.Millisecond == y.Millisecond;
		}

		private static bool CompareDateTime( DateTime? x, DateTime? y )
		{
			return CompareDateTime( x.Value, y.Value );
		}

		private static bool CompareDateTime( DateTimeOffset x, DateTimeOffset y )
		{
			return CompareDateTime( x.DateTime, y.DateTime ) && x.Offset == y.Offset;
		}

		private static bool CompareDateTime( DateTimeOffset? x, DateTimeOffset? y )
		{
			return CompareDateTime( x.Value, y.Value );
		}

<#+
	foreach ( var contextSetting in new[] { "Native", "UnixEpoc" } )
	{
		foreach ( var kind in new[] { new { Label = "Local", Property = "Now" }, new { Label = "Utc", Property = "UtcNow" } }
			)
		{
			#>
		[Test]
		public void TestDateTimeMemberAttributes_<#= contextSetting #>Context_<#= kind.Label #>()
		{
			var context = GetSerializationContext();
<#+
			if ( contextSetting == "Navie" )
			{
#>
			Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.<#= contextSetting #> ) );
<#+
			}
			else
			{
#>
			context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.<#= contextSetting #>;
<#+
			}
#>
			var target = this.CreateTarget<AnnotatedDateTimes>( context );
			using ( var buffer = new MemoryStream() )
			{
				var input = new AnnotatedDateTimes( DateTimeOffset.<#= kind.Property #> );
				target.Pack( buffer, input );
				buffer.Position = 0;
				var result = target.Unpack( buffer );
<#+

			foreach ( var memberType in new[] { "Field", "Property" } )
			{
				var suffix = String.Format( CultureInfo.InvariantCulture, "DateTime{0}", memberType );
				if ( contextSetting == "Native" )
				{
#>

				// Kind is preserved.
				Assert.That( result.Vanilla<#= suffix #>, Is.EqualTo( input.Vanilla<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #> );
				Assert.That( result.Default<#= suffix #>, Is.EqualTo( input.Default<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Default<#= suffix #>, input.Default<#= suffix #> );
<#+
				}
				else
				{
#>

				// UTC is forced.
				Assert.That( CompareDateTime( result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #>.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #> );
				Assert.That( CompareDateTime( result.Default<#= suffix #>, input.Default<#= suffix #>.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Default<#= suffix #>, input.Default<#= suffix #> );
<#+
				}
#>
				Assert.That( result.Native<#= suffix #>, Is.EqualTo( input.Native<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Native<#= suffix #>, input.Native<#= suffix #> );
				Assert.That( CompareDateTime( result.UnixEpoc<#= suffix #>, input.UnixEpoc<#= suffix #>.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpoc<#= suffix #>, input.UnixEpoc<#= suffix #> );

<#+
				suffix = String.Format( CultureInfo.InvariantCulture, "DateTimeOffset{0}", memberType );
				if ( contextSetting == "Native" )
				{
#>

				// Offset is preserved. 
				Assert.That( result.Vanilla<#= suffix #>, Is.EqualTo( input.Vanilla<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #> );
				Assert.That( result.Default<#= suffix #>, Is.EqualTo( input.Default<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Default<#= suffix #>, input.Default<#= suffix #> );
<#+
				}
				else if ( kind.Label == "Utc" )
				{
#>

				// UTC == UTC
				Assert.That( CompareDateTime( result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #> );
				Assert.That( CompareDateTime( result.Default<#= suffix #>, input.Default<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Default<#= suffix #>, input.Default<#= suffix #> );
<#+
				}
				else
				{
#>

				// UTC is forced.
				Assert.That( CompareDateTime( result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #>.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Vanilla<#= suffix #>, input.Vanilla<#= suffix #> );
				Assert.That( CompareDateTime( result.Default<#= suffix #>, input.Default<#= suffix #>.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Default<#= suffix #>, input.Default<#= suffix #> );
<#+
				}
#>
				Assert.That( result.Native<#= suffix #>, Is.EqualTo( input.Native<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.Native<#= suffix #>, input.Native<#= suffix #> );
<#+
				if ( kind.Label == "Utc" )
				{
#>
				// UTC == UTC
				Assert.That( CompareDateTime( result.UnixEpoc<#= suffix #>, input.UnixEpoc<#= suffix #> ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpoc<#= suffix #>, input.UnixEpoc<#= suffix #> );
<#+
				}
				else
				{
#>
				// UTC is forced.
				Assert.That( CompareDateTime( result.UnixEpoc<#= suffix #>, input.UnixEpoc<#= suffix #>.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpoc<#= suffix #>, input.UnixEpoc<#= suffix #> );
<#+
				}
			}
#>
			}
		}

<#+
		}
	}
#>

		[Test]
		public void TestUri()
		{
			TestCore( new Uri( "http://www.example.com" ), stream => new Uri( Unpacking.UnpackString( stream ) ), null );
		}

<#+
	if ( !forIos )
	{
		// Not needed because generation itself has been done.
#>
		[Test]
		public void TestComplexObject_WithShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = false;
			try 
			{
				this.TestComplexObjectCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		[Test]
		public void TestComplexObject_WithoutShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = true;
			try 
			{
				this.TestComplexObjectCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		private void TestComplexObjectCore( SerializationContext context )
		{
			var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } };
			target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" );
			target.Points.Add( 123 );
			TestCoreWithVerify( target, context );
		}

#if FEATURE_TAP
		[Test]
		public async Task TestComplexObjectAsync_WithShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = false;
			try 
			{
				await this.TestComplexObjectAsyncCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		[Test]
		public async Task TestComplexObjectAsync_WithoutShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = true;
			try 
			{
				await this.TestComplexObjectAsyncCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		private async Task TestComplexObjectAsyncCore( SerializationContext context )
		{
			var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } };
			target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" );
			target.Points.Add( 123 );
			await TestCoreWithVerifyAsync( target, context );
		}
#endif // FEATURE_TAP

		[Test]
		public void TestComplexTypeWithoutAnyAttribute_WithShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = false;
			try 
			{
				this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		[Test]
		public void TestComplexTypeWithoutAnyAttribute_WithoutShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = true;
			try 
			{
				this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		private void TestComplexTypeWithoutAnyAttribute( SerializationContext context )
		{
			var target = new ComplexTypeWithoutAnyAttribute() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } };
			target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" );
			TestCoreWithVerify( target, context );
		}

		[Test]
		public void TestTypeWithMissingMessagePackMemberAttributeMember()
		{
			this.TestTypeWithMissingMessagePackMemberAttributeMemberCore( GetSerializationContext() );
		}

		private void TestTypeWithMissingMessagePackMemberAttributeMemberCore( SerializationContext context )
		{
			var target = new TypeWithMissingMessagePackMemberAttributeMember();
			TestCoreWithVerify( target, context );
		}

		[Test]
		public void TestTypeWithInvalidMessagePackMemberAttributeMember()
		{
			Assert.Throws<SerializationException>( () => this.CreateTarget<TypeWithInvalidMessagePackMemberAttributeMember>( GetSerializationContext() ) );
		}

		[Test]
		public void TestTypeWithDuplicatedMessagePackMemberAttributeMember()
		{
			Assert.Throws<SerializationException>( () => this.CreateTarget<TypeWithDuplicatedMessagePackMemberAttributeMember>( GetSerializationContext() ) );
		}

		[Test]
		public void TestComplexObjectTypeWithDataContract_WithShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = false;
			try 
			{
				this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		[Test]
		public void TestComplexObjectTypeWithDataContract_WithoutShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = true;
			try 
			{
				this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		private void TestComplexObjectTypeWithDataContractCore( SerializationContext context )
		{
			var target = new ComplexTypeWithDataContract() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } };
			target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" );
#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
			target.NonSerialized = new DefaultTraceListener();
#else
			target.NonSerialized = new Stopwatch();
#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
			TestCoreWithVerify( target, context );
		}

		[Test]
		public void TestComplexTypeWithDataContractWithOrder_WithShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = false;
			try 
			{
				this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		[Test]
		public void TestComplexTypeWithDataContractWithOrder_WithoutShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = true;
			try 
			{
				this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		private void TestComplexTypeWithDataContractWithOrderCore( SerializationContext context )
		{
			var target = new ComplexTypeWithDataContractWithOrder() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } };
			target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" );
#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
			target.NonSerialized = new DefaultTraceListener();
#else
			target.NonSerialized = new Stopwatch();
#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
			TestCoreWithVerify( target, context );
		}

		[Test]
		public void TestComplexObjectTypeWithNonSerialized_WithShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = false;
			try 
			{
				this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
		}

		[Test]
		public void TestComplexObjectTypeWithNonSerialized_WithoutShortcut()
		{
			SerializerDebugging.AvoidsGenericSerializer = true;
			try 
			{
				this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() );
			}
			finally
			{
				SerializerDebugging.AvoidsGenericSerializer = false;
			}
	}

		private void TestComplexObjectTypeWithNonSerializedCore( SerializationContext context )
		{
			var target = new ComplexTypeWithNonSerialized() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } };
			target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" );
#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
			target.NonSerialized = new DefaultTraceListener();
#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
			TestCoreWithVerify( target, context );
		}

		[Test]
		public void TestDataMemberAttributeOrderWithOneBase()
		{
			var context = GetSerializationContext();
			var value = new ComplexTypeWithOneBaseOrder();
			var target = this.CreateTarget<ComplexTypeWithOneBaseOrder>( context );
			using ( var buffer = new MemoryStream() )
			{
				target.Pack( buffer, value );
				buffer.Position = 0;
				var unpacked = target.Unpack( buffer );
				Assert.That( unpacked.One, Is.EqualTo( value.One ) );
				Assert.That( unpacked.Two, Is.EqualTo( value.Two ) );
			}
		}

#if FEATURE_TAP

		[Test]
		public async Task TestDataMemberAttributeOrderWithOneBaseAsync()
		{
			var context = GetSerializationContext();
			var value = new ComplexTypeWithOneBaseOrder();
			var target = this.CreateTarget<ComplexTypeWithOneBaseOrder>( context );
			using ( var buffer = new MemoryStream() )
			{
				await target.PackAsync( buffer, value ).ConfigureAwait( false );
				buffer.Position = 0;
				var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false );
				Assert.That( unpacked.One, Is.EqualTo( value.One ) );
				Assert.That( unpacked.Two, Is.EqualTo( value.Two ) );
			}
		}

#endif // FEATURE_TAP

		[Test]
		public void TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatible()
		{
			var context = GetSerializationContext();
			context.CompatibilityOptions.OneBoundDataMemberOrder = true;
			var value = new ComplexTypeWithOneBaseOrder();
			var target = this.CreateTarget<ComplexTypeWithOneBaseOrder>( context );
			using ( var buffer = new MemoryStream() )
			{
				target.Pack( buffer, value );
				buffer.Position = 0;
				var unpacked = target.Unpack( buffer );
				Assert.That( unpacked.One, Is.EqualTo( value.One ) );
				Assert.That( unpacked.Two, Is.EqualTo( value.Two ) );
			}
		}

#if FEATURE_TAP

		[Test]
		public async Task TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatibleAsync()
		{
			var context = GetSerializationContext();
			context.CompatibilityOptions.OneBoundDataMemberOrder = true;
			var value = new ComplexTypeWithOneBaseOrder();
			var target = this.CreateTarget<ComplexTypeWithOneBaseOrder>( context );
			using ( var buffer = new MemoryStream() )
			{
				await target.PackAsync( buffer, value ).ConfigureAwait( false );
				buffer.Position = 0;
				var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false );
				Assert.That( unpacked.One, Is.EqualTo( value.One ) );
				Assert.That( unpacked.Two, Is.EqualTo( value.Two ) );
			}
		}

#endif // FEATURE_TAP

		[Test]
		public void TestDataMemberAttributeOrderWithOneBaseDeserialize()
		{
			var context = GetSerializationContext();
			context.SerializationMethod = SerializationMethod.Array;
			var target = this.CreateTarget<ComplexTypeWithOneBaseOrder>( context );
			using ( var buffer = new MemoryStream() )
			{
				buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } );
				buffer.Position = 0;
				var unpacked = target.Unpack( buffer );
				Assert.That( unpacked.One, Is.EqualTo( 10 ) );
				Assert.That( unpacked.Two, Is.EqualTo( 20 ) );
			}
		}

#if FEATURE_TAP

		[Test]
		public async Task TestDataMemberAttributeOrderWithOneBaseDeserializeAsync()
		{
			var context = GetSerializationContext();
			context.SerializationMethod = SerializationMethod.Array;
			var target = this.CreateTarget<ComplexTypeWithOneBaseOrder>( context );
			using ( var buffer = new MemoryStream() )
			{
				buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } );
				buffer.Position = 0;
				var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false );
				Assert.That( unpacked.One, Is.EqualTo( 10 ) );
				Assert.That( unpacked.Two, Is.EqualTo( 20 ) );
			}
		}

#endif // FEATURE_TAP

		[Test]
		public void TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatible()
		{
			var context = GetSerializationContext();