From 26022db3655c42b3c8caf02bde57fec8d8776b47 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 5 Sep 2018 22:34:57 +0900
Subject: [PATCH 01/36] Add unit tests for conversion from DateTime[Offset] to
 Timestamp.

---
 .../TimestampTest.Conversion.cs               | 375 ++++++++++++++++++
 .../TimestampTest.Conversion.tt               |  29 ++
 2 files changed, 404 insertions(+)

diff --git a/test/MsgPack.UnitTest/TimestampTest.Conversion.cs b/test/MsgPack.UnitTest/TimestampTest.Conversion.cs
index e57acad2f..2dd85b81b 100644
--- a/test/MsgPack.UnitTest/TimestampTest.Conversion.cs
+++ b/test/MsgPack.UnitTest/TimestampTest.Conversion.cs
@@ -285,6 +285,7 @@ private static void AssertSubseconds( Timestamp target, DateTime expected )
 			Assert.That( target.Microsecond, Is.EqualTo( ticks / 10 ), "Microsecond" );
 			Assert.That( target.Nanosecond, Is.EqualTo( ( ticks % 10 ) * 100 ), "Nanosecond" );
 		}
+
 		[Test]
 		public void TestFromDateTimeOffset_UtcNow_OK()
 		{
@@ -536,5 +537,379 @@ private static void AssertSubseconds( Timestamp target, DateTimeOffset expected
 			Assert.That( target.Microsecond, Is.EqualTo( ticks / 10 ), "Microsecond" );
 			Assert.That( target.Nanosecond, Is.EqualTo( ( ticks % 10 ) * 100 ), "Nanosecond" );
 		}
+
+#if !NET35 && !SILVERLIGHT && !NETSTANDARD1_1
+
+		[Test]
+		public void TestFromDateTime_UnixEpoc_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeMilliseconds( 0 ).DateTime;
+			var target = Timestamp.FromDateTime( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTime_UnixEpocMinus1Millisecond_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeMilliseconds( -1 ).DateTime;
+			var target = Timestamp.FromDateTime( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTime_UnixEpocPlus1Millisecond_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeMilliseconds( 1 ).DateTime;
+			var target = Timestamp.FromDateTime( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTime_UnixEpocMinusSecond_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeSeconds( -1 ).DateTime;
+			var target = Timestamp.FromDateTime( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTime_UnixEpocPlus1Second_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeSeconds( 1 ).DateTime;
+			var target = Timestamp.FromDateTime( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestToDateTime_UnixEpoc_OK()
+		{
+			var source = default( Timestamp );
+			var target = source.ToDateTime();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTime_UnixEpocMinus1Millisecond_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromMilliseconds( -1 ) );
+			var target = source.ToDateTime();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTime_UnixEpocPlus1Millisecond_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromMilliseconds( 1 ) );
+			var target = source.ToDateTime();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTime_UnixEpocMinus1Second_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromSeconds( -1 ) );
+			var target = source.ToDateTime();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTime_UnixEpocPlus1Second_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromSeconds( 1 ) );
+			var target = source.ToDateTime();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestFromDateTimeOffset_UnixEpoc_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeMilliseconds( 0 );
+			var target = Timestamp.FromDateTimeOffset( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTimeOffset_UnixEpocMinus1Millisecond_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeMilliseconds( -1 );
+			var target = Timestamp.FromDateTimeOffset( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTimeOffset_UnixEpocPlus1Millisecond_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeMilliseconds( 1 );
+			var target = Timestamp.FromDateTimeOffset( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTimeOffset_UnixEpocMinus1Second_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeSeconds( -1 );
+			var target = Timestamp.FromDateTimeOffset( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestFromDateTimeOffset_UnixEpocPlus1Second_OK()
+		{
+			var source = DateTimeOffset.FromUnixTimeSeconds( 1 );
+			var target = Timestamp.FromDateTimeOffset( source );
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+		}
+
+		[Test]
+		public void TestToDateTimeOffset_UnixEpoc_OK()
+		{
+			var source = default( Timestamp );
+			var target = source.ToDateTimeOffset();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTimeOffset_UnixEpocMinus1Millisecond_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromMilliseconds( -1 ) );
+			var target = source.ToDateTimeOffset();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTimeOffset_UnixEpocPlus1Millisecond_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromMilliseconds( 1 ) );
+			var target = source.ToDateTimeOffset();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTimeOffset_UnixEpocMinus1Second_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromSeconds( -1 ) );
+			var target = source.ToDateTimeOffset();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+		[Test]
+		public void TestToDateTimeOffset_UnixEpocPlus1Second_OK()
+		{
+			var source = default( Timestamp ).Add( TimeSpan.FromSeconds( 1 ) );
+			var target = source.ToDateTimeOffset();
+			var expected = source;
+			Assert.That( target.Year, Is.EqualTo( expected.Year ), "Year" );
+			Assert.That( target.Month, Is.EqualTo( expected.Month ), "Month" );
+			Assert.That( target.Day, Is.EqualTo( expected.Day ), "Day" );
+			Assert.That( target.DayOfYear, Is.EqualTo( expected.DayOfYear ), "DayOfYear" );
+			Assert.That( target.DayOfWeek, Is.EqualTo( expected.DayOfWeek ), "DayOfWeek" );
+			Assert.That( target.Hour, Is.EqualTo( expected.Hour ), "Hour" );
+			Assert.That( target.Minute, Is.EqualTo( expected.Minute ), "Minute" );
+			Assert.That( target.Second, Is.EqualTo( expected.Second ), "Second" );
+			Assert.That( target.Millisecond, Is.EqualTo( expected.Millisecond ), "Millisecond" );
+			AssertSubseconds( target, expected );
+			AssertUtc( target );
+		}
+
+#endif // NET35 && !SILVERLIGHT && !NETSTANDARD1_1
 	}
 }
diff --git a/test/MsgPack.UnitTest/TimestampTest.Conversion.tt b/test/MsgPack.UnitTest/TimestampTest.Conversion.tt
index d0030d8a3..1621c3772 100644
--- a/test/MsgPack.UnitTest/TimestampTest.Conversion.tt
+++ b/test/MsgPack.UnitTest/TimestampTest.Conversion.tt
@@ -126,9 +126,38 @@ foreach ( var type in new [] { "DateTime", "DateTimeOffset" } )
 			Assert.That( target.Microsecond, Is.EqualTo( ticks / 10 ), "Microsecond" );
 			Assert.That( target.Nanosecond, Is.EqualTo( ( ticks % 10 ) * 100 ), "Nanosecond" );
 		}
+
 <#
 }
 #>
+#if !NET35 && !SILVERLIGHT && !NETSTANDARD1_1
+
+<#
+	WriteConversionTest( "FromDateTime_UnixEpoc_OK",					"DateTimeOffset.FromUnixTimeMilliseconds( 0 ).DateTime",	"Timestamp.FromDateTime( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTime_UnixEpocMinus1Millisecond_OK",	"DateTimeOffset.FromUnixTimeMilliseconds( -1 ).DateTime",	"Timestamp.FromDateTime( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTime_UnixEpocPlus1Millisecond_OK",	"DateTimeOffset.FromUnixTimeMilliseconds( 1 ).DateTime",	"Timestamp.FromDateTime( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTime_UnixEpocMinusSecond_OK",			"DateTimeOffset.FromUnixTimeSeconds( -1 ).DateTime",	"Timestamp.FromDateTime( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTime_UnixEpocPlus1Second_OK",			"DateTimeOffset.FromUnixTimeSeconds( 1 ).DateTime",	"Timestamp.FromDateTime( {0} )",	null,	null );
+
+	WriteConversionTest( "ToDateTime_UnixEpoc_OK",						"default( Timestamp )",											"{0}.ToDateTime()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTime_UnixEpocMinus1Millisecond_OK",		"default( Timestamp ).Add( TimeSpan.FromMilliseconds( -1 ) )",	"{0}.ToDateTime()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTime_UnixEpocPlus1Millisecond_OK",		"default( Timestamp ).Add( TimeSpan.FromMilliseconds( 1 ) )",	"{0}.ToDateTime()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTime_UnixEpocMinus1Second_OK",			"default( Timestamp ).Add( TimeSpan.FromSeconds( -1 ) )",	"{0}.ToDateTime()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTime_UnixEpocPlus1Second_OK",			"default( Timestamp ).Add( TimeSpan.FromSeconds( 1 ) )",	"{0}.ToDateTime()",	null,	"AssertUtc( {0} )" );
+
+	WriteConversionTest( "FromDateTimeOffset_UnixEpoc_OK",					"DateTimeOffset.FromUnixTimeMilliseconds( 0 )",		"Timestamp.FromDateTimeOffset( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTimeOffset_UnixEpocMinus1Millisecond_OK",	"DateTimeOffset.FromUnixTimeMilliseconds( -1 )",	"Timestamp.FromDateTimeOffset( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTimeOffset_UnixEpocPlus1Millisecond_OK",	"DateTimeOffset.FromUnixTimeMilliseconds( 1 )",		"Timestamp.FromDateTimeOffset( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTimeOffset_UnixEpocMinus1Second_OK",		"DateTimeOffset.FromUnixTimeSeconds( -1 )",	"Timestamp.FromDateTimeOffset( {0} )",	null,	null );
+	WriteConversionTest( "FromDateTimeOffset_UnixEpocPlus1Second_OK",		"DateTimeOffset.FromUnixTimeSeconds( 1 )",		"Timestamp.FromDateTimeOffset( {0} )",	null,	null );
+
+	WriteConversionTest( "ToDateTimeOffset_UnixEpoc_OK",						"default( Timestamp )",											"{0}.ToDateTimeOffset()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTimeOffset_UnixEpocMinus1Millisecond_OK",		"default( Timestamp ).Add( TimeSpan.FromMilliseconds( -1 ) )",	"{0}.ToDateTimeOffset()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTimeOffset_UnixEpocPlus1Millisecond_OK",		"default( Timestamp ).Add( TimeSpan.FromMilliseconds( 1 ) )",	"{0}.ToDateTimeOffset()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTimeOffset_UnixEpocMinus1Second_OK",			"default( Timestamp ).Add( TimeSpan.FromSeconds( -1 ) )",	"{0}.ToDateTimeOffset()",	null,	"AssertUtc( {0} )" );
+	WriteConversionTest( "ToDateTimeOffset_UnixEpocPlus1Second_OK",				"default( Timestamp ).Add( TimeSpan.FromSeconds( 1 ) )",	"{0}.ToDateTimeOffset()",	null,	"AssertUtc( {0} )" );
+#>
+#endif // NET35 && !SILVERLIGHT && !NETSTANDARD1_1
 	}
 }
 <#+

From 78b511f1ceb6fe933578046ebd642cc333deae27 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 5 Sep 2018 23:17:25 +0900
Subject: [PATCH 02/36] Fix exception in conversion from DateTime[Offset] to
 Timestamp. #296

If the date time is before Unix epoc and it has subsecond value,
internal divrem operation returns negative remains and it causes exception.
This commit add adjustment for this situation.
---
 src/MsgPack/Timestamp.Conversion.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/MsgPack/Timestamp.Conversion.cs b/src/MsgPack/Timestamp.Conversion.cs
index f6fbc24ef..56b28063c 100644
--- a/src/MsgPack/Timestamp.Conversion.cs
+++ b/src/MsgPack/Timestamp.Conversion.cs
@@ -133,6 +133,14 @@ private static void FromOffsetTicks( long ticks, out long unixEpocSeconds, out i
 			long remaining;
 			unixEpocSeconds = DivRem( ticks, SecondsToTicks, out remaining );
 			nanoSeconds = unchecked( ( int )remaining ) * 100;
+			if ( nanoSeconds < 0 )
+			{
+				// In this case, we must adjust these values
+				// from "negative nanosec from nearest larger negative integer"
+				// to "positive nanosec from nearest smaller nagative integer".
+				unixEpocSeconds -= 1;
+				nanoSeconds = ( MaxNanoSeconds + 1 ) + nanoSeconds;
+			}
 		}
 
 		/// <summary>

From 44912facba43f0d285d1333a2ee4437df9f85276 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 5 Sep 2018 23:17:39 +0900
Subject: [PATCH 03/36] Fix changelog.

---
 CHANGES.txt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGES.txt b/CHANGES.txt
index 0de4aca8e..326598977 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -753,3 +753,8 @@ Release 1.0.0 2018-6-14
   * Fix map keys order emitted by asymmetric (serialization only) serializer are inconsistent across platform.
   * Fix Unity build does not honor serialization related attributes correctly.
   * Fix internal inconsitency between serialization related attributes detection and their parameter retrieval.
+
+Release 1.0.1 2018-09-09
+
+  BUG FIXES
+  * Fix conversion from DateTime[Offset] to Timestamp failure for before Unix epoc. #296

From b707db201ae23c23db443a78c521a04def596e27 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 16:52:24 +0900
Subject: [PATCH 04/36] Renew test certificate

---
 ...sgPack.UnitTest.BclExtensions.WinRT.csproj |   5 +++--
 ...tTest.BclExtensions.WinRT_TemporaryKey.pfx | Bin 2536 -> 2536 bytes
 .../MsgPack.UnitTest.Uwp.Aot.csproj           |   2 +-
 .../MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx | Bin 2536 -> 2536 bytes
 .../MsgPack.UnitTest.Uwp.csproj               |   5 +++--
 .../MsgPack.UnitTest.Uwp_TemporaryKey.pfx     | Bin 2536 -> 2536 bytes
 .../MsgPack.UnitTest.WinRT.csproj             |   5 +++--
 .../MsgPack.UnitTest.WinRT_TemporaryKey.pfx   | Bin 2536 -> 2536 bytes
 8 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj b/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj
index d1374018d..f262117be 100644
--- a/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj
+++ b/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj
@@ -15,7 +15,7 @@
     <PackageCertificateKeyFile>MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx</PackageCertificateKeyFile>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
-    <PackageCertificateThumbprint>34322AD6CF171CC843FCCE936CB6B9B616B961E1</PackageCertificateThumbprint>
+    <PackageCertificateThumbprint>AA68CFB533B03B5B4FAD8AE85A404BD5936CB7C7</PackageCertificateThumbprint>
     <TargetPlatformVersion>8.1</TargetPlatformVersion>
     <MinimumVisualStudioVersion>12</MinimumVisualStudioVersion>
     <TargetFrameworkVersion />
@@ -23,7 +23,8 @@
   </PropertyGroup>
   <Import Project="..\..\MsgPack.Common.props" />
   <PropertyGroup>
-    <DocumentationFile></DocumentationFile>
+    <DocumentationFile>
+    </DocumentationFile>
     <DefineConstants>$(DefineConstants);NETFX_CORE;NETSTANDARD1_1;FEATURE_TAP;MSTEST</DefineConstants>
     <NoWarn>;2008</NoWarn>
   </PropertyGroup>
diff --git a/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx b/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx
index 322dc6f60273382f4c1e512a2648a9ff5266e2fd..9c3c1d01314c6908e274dbc71ada95c708e87f6a 100644
GIT binary patch
delta 2372
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

delta 2372
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

diff --git a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
index ac6872671..405c158f6 100644
--- a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
+++ b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
@@ -14,7 +14,7 @@
     <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <PackageCertificateKeyFile>MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx</PackageCertificateKeyFile>
     <UnitTestPlatformVersion Condition="'$(UnitTestPlatformVersion)' == ''">14.0</UnitTestPlatformVersion>
-    <PackageCertificateThumbprint>C125CA52683091C62F7746FF9A159E44B2A18673</PackageCertificateThumbprint>
+    <PackageCertificateThumbprint>880646284800F8F3356B8C7E3E734562D8BB304F</PackageCertificateThumbprint>
   </PropertyGroup>
   <Import Project="..\..\MsgPack.Common.props" />
   <PropertyGroup>
diff --git a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx
index bdea5d9135657d2b969e5d5c99421111534fcac8..8a0d0bd470c6ec815e7ac310d4683765e23db5e3 100644
GIT binary patch
delta 2372
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

delta 2372
zcmV-K3A^^_6X+9vFoFr>0s#Xsf(f7o2`Yw2hW8Bt2LYgh36TVX35_s<35hU*1^NaF
zDuzgg_YDCD0ic2f>jZ)Y=P-f=<1m5+-v$dRhDe6@4FL=a0Ro_c1pY9B1o|)>1_~;M
zNQU<f0So~HFb)I=KM3!O1K!9d0s;rn1cC(Eniq}q(DAf?Dr!?R?iAoy==;c<4ePYS
zh7fcLs{c_mU#P<-36c$M2xy`iK{J0bNjB}dowT)+*SOrH;w40yFrvx7?o^UotUIV3
zQC_lYD5;w67E|FSkgu5m2XF;-7!-Tn7qbt*ka}x*qV(dV;sUU`#I<Yo21PstEpG+o
z7{}mTHT~p&JSD5kAN?Y|&%#)Dsx4+C@hvrkU^{_tUtn(h`>6Tre7Xn2YZsbjrg^Oo
z*3(DAx_*p#mgsW~!3eEBS$|<U)CQmn>^gO~{>&nF4-!bT(y^UA@AX#sA*hiHU5JP{
zVC*d6-JN983pi@*BIC1XPgaGQ2kH)(92v**LpC&j^=AACX;faT=l+XV#`JPa1#Mq1
zX5ZuA0QkhMJjd%@n|`F?;?czyQsGJ>HioQPk~j`{Fi$aj;ffnXsJW$MqSVK`#oNf#
zPo!cr?DayQW0QQ&5r#FHg7p^4Uqqh?wgN;QI;XMJlyA%XtH}Tt!l@#=@%N&xDMZj|
zXOR7WXol66P;lsynVYNgV$h@oeoG+b*xzww5BjrfF5z>-chP%T2|TP;Rmv@cpt3M_
zJ~}W<gucWHq(9c^JRoFPELUv`6usja(x>=(M7i;eKSa<nSYp=2JCe4sS4Dj6762N+
zv6G?qVScfq(z*Ex%_R^>^#v_q%Sf<-2(CGQkOVatUrCUa%`$<u-&@g^nhO&aqU)}`
z@6QR5Az;co-2{#$V&ea*s#z^;Bzf@(j>~_&QhofIn!x~Xqc)i0H4j~>=yWc1lo_=r
zYLzg~Ew=nO-G@VFZ0;h>9+#g5hQv;(MovjpQA3L)EQ;wv3no?y$>A;)#{m!zWGi%k
z{k-cj82Av$i7Q;zIu3~NUhF^9wYRUZAuYd6x2^^1B4$g<%!V(Aj||7C%Nf&xJ;{I(
zpX=X<%*!bW2I!u>Rz^@1M@grynT35xAD1RajgY_*m?>;6mQ6&)eA0z$ZI38N%ec%m
zK8SLV2k2aTkWzW{#I}4y+h`5msEb#B9scju3e3iLC54i{$Y;DCk4G4saoP;p*w1!i
zyAKjMyTr71aoF4o79hA%em`;A$@DBc+$gR}e*}9PFm#~O)VbE?v)T7@{0uJ?!B~8o
z_>jJhqb4Z!V!uNJE|K4~da%Z1Qf;=6vYCy}03iVTd57t+8%!p4P<+G@{2ir#Xrn*n
zX|y3;2v}2S^JB7JenigKA&i=1U~q;m80g+NV4*HE<nB)sFFrYs0dLvt4Cx2u^|x$D
zK(-K|rWvJ~Vdn_aWIFs4?&+>G&&Ag?6gJ+TjJHN)lb>iSlz<Il=`wO};UgA8hQy3$
zI#SlYg1?}lr8}4v5vyQdpb1ca!gEi-*j2Sw#{eqv!-Ix7C39ks`j-Q>1odU@R8amn
z1_ob|7PU8#ziU9d#yaWig<jw|9=BWz-%uj-)jduPQP6b$NrndWYp!=ZjNg2%B4jfE
zUJe83wnq$Cq^_yW)pvXcMylpcl!l9FmtZ-oNYi)=c(cL{!h%|cRKjsuY;t4DZmS-J
zkE!r*R3&X2LQ7mH3%5<?kSKco+Dwp$DLWW%$+r<3X<88#Nf$c<6sB^mAoLA8e^fwG
zDq}-7%h6pj;9H>u+!1FujPLx73W#b0!ha;x#WIsf1u92l05$+)0A>I(0673;0AT<v
z05$+(05bqI04)GC05Sk$0A>I!0AT<#05||N04)GC05t$*05kwM05SkL05t$%0A>JV
z0A-W81)6{T3(4bP4~0Ae0te85f&)Mtk19b}=N0>=s0}VRlK~UE_{Xe%&L-Cv*dk+`
zs`)Tyxx{DNjn97)6Y?Yi=}?F=M7IkBbo|%XqVZagqQJZp_={r2NiC{SrB7#mm>c9t
z1V!i*@UaVHLaN9Cih@7<sCoV~v?H_ZD|~!oNvVH~;Yw@2+<=mXv5aV?Gr^&MvyRE0
zv~$)#sNAuV>1Ynfj}ZD~=zkc^N4#c+FKvwICxOZCi(A1Q*p%msh@)xFE7i;Mc>z(r
z%Y}5p$q0!@%175eOba28qBeCC7sDExJ%1nq`DH3?vk8a(GK!BLRN0RrUMCSzT@KU_
zM8AKrd`xl7`)U!%uJnKo4&ZDXKUVvHH7j#_X-TZB<NIWV|Ahca$~~H!E&i^}>0{R&
z5t$pJ2!s%=h|fNwOoWizEeS8zoaC^8=Oj*L+J*=3tqouU{0cz1_e);+cx%=GL%Pu(
zdK#0j<>Y|XkO_dGjyn$V%%Iab(82*iF+6__3(g~R-_^n6Q&dm|Ee+Ca*W}P+li}Vm
zfY65m9LMWhA9ndUKO;;>VPwJR#x8HItPnY<piGTh?_GQjPwr?twZ4ZnErhntA*`{A
z36hUH8Dk}d)c4Ug%gf-Wp(w^$FpQy=lx6c*JG^j6R`d(a6kcc!)(AQD$vJ-GGueMW
zxh`e`oA7&PX6LakiCBm;7_nrb@P1|fy|@C)xk(|9Tl7)WXLspR?|-=ID+4Y!xmn(4
z(YWVTl;!E4_^qxUvRpJvLFWlD*c;>|{67C`C`M2KeZuVJ=wh0I&1m)CS^q<Cqo6Q@
z&4@j|XJxk;Hkb`3lun3s+C0SqzO;XuqBeW#PH&}=;oGdp2&1j#6#-suOdDch*+gQS
z0i2s85LiXB+tj#J5fm+LJAm9YN$ah$8-%(a!7<kyeg0HwHn{HiKd`6toR!zy=CS3q
z?2FKgEUdz>W;=!DHRHxCIG3>T5=o%K+sp4=|M~aCeyn+}lSgw?3mp`ekS~9nHbVLu
z(#Zd?l%PQ+sCo3em`0sq%BhL$`D4qo8QZV9m_V-er9{}uSjHkc;|^j_k6nV1&iC$y
z{6vr;uGPo&VOH!qWv?nsish-v3gAQz7e(6{U@$u{A20_71uG5%0vZGqTc$e(+fGr`
qF>dX72rBtwMkTa71QfnM+bR@8N8>ZA!flq&s`~WzZJ;;;0te7MiCyae

diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
index 081f56673..6f5dfbce1 100644
--- a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
+++ b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
@@ -14,11 +14,12 @@
     <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <PackageCertificateKeyFile>MsgPack.UnitTest.Uwp_TemporaryKey.pfx</PackageCertificateKeyFile>
     <UnitTestPlatformVersion Condition="'$(UnitTestPlatformVersion)' == ''">14.0</UnitTestPlatformVersion>
-    <PackageCertificateThumbprint>0CEFF2E3DC6DD3A7245B2FB641B6DE056C5A79D9</PackageCertificateThumbprint>
+    <PackageCertificateThumbprint>807856C98966D121CA69C33F7D6475CF03AA8633</PackageCertificateThumbprint>
   </PropertyGroup>
   <Import Project="..\..\MsgPack.Common.props" />
   <PropertyGroup>
-    <DocumentationFile></DocumentationFile>
+    <DocumentationFile>
+    </DocumentationFile>
     <DefineConstants>$(DefineConstants);NETFX_CORE;WINDOWS_UWP;NETSTANDARD1_3;FEATURE_TAP</DefineConstants>
     <NoWarn>;2008</NoWarn>
     <SignAssembly>false</SignAssembly>
diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx
index d9a6dd76134fc2988d3c40cb918207f3285d700f..604dac0b06b2be4477b423f66665c174ef9a9e0e 100644
GIT binary patch
delta 2283
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
F2hdeGM6dt=

delta 2283
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
F2hcWQJ8J*{

diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
index e0e54b445..ef2acfe77 100644
--- a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
+++ b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
@@ -11,7 +11,7 @@
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{BC8A1FFA-BEE3-4634-8014-F334798102B3};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <PackageCertificateKeyFile>MsgPack.UnitTest.WinRT_TemporaryKey.pfx</PackageCertificateKeyFile>
-    <PackageCertificateThumbprint>A411E1A11B99FF48CFDEDA3098F7F4D0FB6D746D</PackageCertificateThumbprint>
+    <PackageCertificateThumbprint>DEBDFCC31BC8F851996AD84C394EA999CA3ED9D1</PackageCertificateThumbprint>
     <TargetPlatformVersion>8.1</TargetPlatformVersion>
     <MinimumVisualStudioVersion>12</MinimumVisualStudioVersion>
     <TargetFrameworkVersion />
@@ -19,7 +19,8 @@
   </PropertyGroup>
   <Import Project="..\..\MsgPack.Common.props" />
   <PropertyGroup>
-    <DocumentationFile></DocumentationFile>
+    <DocumentationFile>
+    </DocumentationFile>
     <DefineConstants>$(DefineConstants);NETFX_CORE;NETSTANDARD1_1;FEATURE_TAP;MSTEST</DefineConstants>
     <NoWarn>;2008</NoWarn>
   </PropertyGroup>
diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx
index 66ea08c7a9b446649253983aa236f7a10c0fe1b8..194d5586e4ba259a8dfd83a5fd24003c06e36e8b 100644
GIT binary patch
delta 2283
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
F2hf>PET{kg

delta 2283
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
F2heiPV*>yH


From 90433c8f18131da45c05eadaca7646e1c40ebef7 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 16:25:55 +0900
Subject: [PATCH 05/36] Code cleanup.

* Add ChangeLog entry.
* Code formatting according to .editorconfig settings including member name.
* Fix XML syntax error.
* Add Unit test for all projects.
---
 CHANGES.txt                                   |   5 +
 src/MsgPack/Serialization/BindingOptions.cs   |  23 ++-
 .../Serialization/SerializationContext.cs     |  24 +--
 .../Serialization/SerializationTarget.cs      | 146 +++++++++---------
 .../MessagePackMemberSkipTest.cs              |   8 +
 5 files changed, 109 insertions(+), 97 deletions(-)

diff --git a/CHANGES.txt b/CHANGES.txt
index 326598977..db2afa3b8 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -758,3 +758,8 @@ Release 1.0.1 2018-09-09
 
   BUG FIXES
   * Fix conversion from DateTime[Offset] to Timestamp failure for before Unix epoc. #296
+
+Release 1.1
+
+  NEW FEATURE
+  * Allow programatically ignoring arbitary members via BindingOptions. Thank you @ShrenikOne #282
diff --git a/src/MsgPack/Serialization/BindingOptions.cs b/src/MsgPack/Serialization/BindingOptions.cs
index 741dc3953..29090576d 100644
--- a/src/MsgPack/Serialization/BindingOptions.cs
+++ b/src/MsgPack/Serialization/BindingOptions.cs
@@ -21,7 +21,6 @@
 //
 #endregion -- License Terms --
 
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -34,9 +33,9 @@ namespace MsgPack.Serialization
 	public class BindingOptions
 	{
 		/// <summary>
-		/// Private mapping of types & their member skip list, which needs to ignore as part of serialization.
+		/// Private mapping of types &amp; their member skip list, which needs to ignore as part of serialization.
 		/// </summary>
-		private readonly IDictionary<Type, IEnumerable<string>> typeIgnoringMembersMap = new Dictionary<Type, IEnumerable<string>>();
+		private readonly IDictionary<Type, IEnumerable<string>> _typeIgnoringMembersMap = new Dictionary<Type, IEnumerable<string>>();
 
 		/// <summary>
 		/// Sets the member skip list for a specific target type.
@@ -45,15 +44,15 @@ public class BindingOptions
 		/// <param name="memberSkipList">The member skip list.</param>
 		public void SetIgnoringMembers( Type targetType, IEnumerable<string> memberSkipList )
 		{
-			lock ( this.typeIgnoringMembersMap )
+			lock ( this._typeIgnoringMembersMap )
 			{
-				if ( this.typeIgnoringMembersMap.ContainsKey( targetType ) )
+				if ( this._typeIgnoringMembersMap.ContainsKey( targetType ) )
 				{
-					this.typeIgnoringMembersMap[ targetType ] = memberSkipList;
+					this._typeIgnoringMembersMap[ targetType ] = memberSkipList;
 				}
 				else
 				{
-					this.typeIgnoringMembersMap.Add( targetType, memberSkipList );
+					this._typeIgnoringMembersMap.Add( targetType, memberSkipList );
 				}
 			}
 		}
@@ -65,11 +64,11 @@ public void SetIgnoringMembers( Type targetType, IEnumerable<string> memberSkipL
 		/// <returns>Returns member skip list for a specific target type.</returns>
 		public IEnumerable<string> GetIgnoringMembers( Type targetType )
 		{
-			lock ( this.typeIgnoringMembersMap )
+			lock ( this._typeIgnoringMembersMap )
 			{
-				if ( this.typeIgnoringMembersMap.ContainsKey( targetType ) )
+				if ( this._typeIgnoringMembersMap.ContainsKey( targetType ) )
 				{
-					return this.typeIgnoringMembersMap[ targetType ];
+					return this._typeIgnoringMembersMap[ targetType ];
 				}
 				else
 				{
@@ -84,9 +83,9 @@ public IEnumerable<string> GetIgnoringMembers( Type targetType )
 		/// <returns>Returns all registered types specific ignoring members.</returns>
 		public IDictionary<Type, IEnumerable<string>> GetAllIgnoringMembers()
 		{
-			lock ( this.typeIgnoringMembersMap )
+			lock ( this._typeIgnoringMembersMap )
 			{
-				return this.typeIgnoringMembersMap.ToDictionary( item => item.Key, item => ( IEnumerable<string> )item.Value.ToArray() );
+				return this._typeIgnoringMembersMap.ToDictionary( item => item.Key, item => ( IEnumerable<string> )item.Value.ToArray() );
 			}
 		}
 	}
diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index 1a91f72dd..2d33d0204 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -241,13 +241,13 @@ public SerializationMethod SerializationMethod
 				{
 					case SerializationMethod.Array:
 					case SerializationMethod.Map:
-						{
-							break;
-						}
+					{
+						break;
+					}
 					default:
-						{
-							throw new ArgumentOutOfRangeException( "value" );
-						}
+					{
+						throw new ArgumentOutOfRangeException( "value" );
+					}
 				}
 
 				Contract.EndContractBlock();
@@ -356,13 +356,13 @@ public DateTimeConversionMethod DefaultDateTimeConversionMethod
 					case DateTimeConversionMethod.Native:
 					case DateTimeConversionMethod.UnixEpoc:
 					case DateTimeConversionMethod.Timestamp:
-						{
-							break;
-						}
+					{
+						break;
+					}
 					default:
-						{
-							throw new ArgumentOutOfRangeException( "value" );
-						}
+					{
+						throw new ArgumentOutOfRangeException( "value" );
+					}
 				}
 
 				Contract.EndContractBlock();
diff --git a/src/MsgPack/Serialization/SerializationTarget.cs b/src/MsgPack/Serialization/SerializationTarget.cs
index c31bd31ca..8efe8ab1b 100644
--- a/src/MsgPack/Serialization/SerializationTarget.cs
+++ b/src/MsgPack/Serialization/SerializationTarget.cs
@@ -122,18 +122,18 @@ private static string DetermineCorrespondingMemberName( ParameterInfo parameterI
 			switch ( membersArray.Length )
 			{
 				case 0:
-					{
-						return null;
-					}
+				{
+					return null;
+				}
 				case 1:
-					{
-						return membersArray[ 0 ].MemberName;
-					}
+				{
+					return membersArray[ 0 ].MemberName;
+				}
 				default:
-					{
-						ThrowAmbigiousMatchException( parameterInfo, membersArray );
-						return null;
-					}
+				{
+					ThrowAmbigiousMatchException( parameterInfo, membersArray );
+					return null;
+				}
 			}
 		}
 
@@ -312,26 +312,26 @@ private static bool DetermineCanDeserialize( ConstructorKind kind, Serialization
 			switch ( kind )
 			{
 				case ConstructorKind.Marked:
-					{
-						Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> true: Marked", targetType, kind );
-						return true;
-					}
+				{
+					Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> true: Marked", targetType, kind );
+					return true;
+				}
 				case ConstructorKind.Parameterful:
-					{
-						var result = HasAnyCorrespondingMembers( correspondingMemberNames );
-						Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> {2}: HasAnyCorrespondingMembers", targetType, kind, result );
-						return result;
-					}
+				{
+					var result = HasAnyCorrespondingMembers( correspondingMemberNames );
+					Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> {2}: HasAnyCorrespondingMembers", targetType, kind, result );
+					return result;
+				}
 				case ConstructorKind.Default:
-					{
-						Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> {2}: Default", targetType, kind, allowDefault );
-						return allowDefault;
-					}
+				{
+					Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> {2}: Default", targetType, kind, allowDefault );
+					return allowDefault;
+				}
 				default:
-					{
-						Contract.Assert( kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous, "kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous : " + kind );
-						return false;
-					}
+				{
+					Contract.Assert( kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous, "kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous : " + kind );
+					return false;
+				}
 			}
 		}
 
@@ -637,25 +637,25 @@ private static ConstructorInfo FindDeserializationConstructor( SerializationCont
 			switch ( markedConstructors.Count )
 			{
 				case 0:
-					{
-						break;
-					}
+				{
+					break;
+				}
 				case 1:
-					{
-						// OK use it for deserialization.
-						constructorKind = ConstructorKind.Marked;
-						return markedConstructors[ 0 ];
-					}
+				{
+					// OK use it for deserialization.
+					constructorKind = ConstructorKind.Marked;
+					return markedConstructors[ 0 ];
+				}
 				default:
-					{
-						throw new SerializationException(
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"There are multiple constructors marked with MessagePackDeserializationConstrutorAttribute in type '{0}'.",
-								targetType
-							)
-						);
-					}
+				{
+					throw new SerializationException(
+						String.Format(
+							CultureInfo.CurrentCulture,
+							"There are multiple constructors marked with MessagePackDeserializationConstrutorAttribute in type '{0}'.",
+							targetType
+						)
+					);
+				}
 			}
 
 			// A constructor which has most parameters will be used.
@@ -667,43 +667,43 @@ private static ConstructorInfo FindDeserializationConstructor( SerializationCont
 			switch ( mostRichConstructors.Length )
 			{
 				case 1:
-					{
-						if ( mostRichConstructors[ 0 ].GetParameters().Length == 0 )
-						{
-							if ( context.CompatibilityOptions.AllowAsymmetricSerializer )
-							{
-								constructorKind = ConstructorKind.Default;
-								return mostRichConstructors[ 0 ];
-							}
-							else
-							{
-								throw NewTypeCannotBeSerializedException( targetType );
-							}
-						}
-
-						// OK try use it but it may not handle deserialization correctly.
-						constructorKind = ConstructorKind.Parameterful;
-						return mostRichConstructors[ 0 ];
-					}
-				default:
+				{
+					if ( mostRichConstructors[ 0 ].GetParameters().Length == 0 )
 					{
 						if ( context.CompatibilityOptions.AllowAsymmetricSerializer )
 						{
-							constructorKind = ConstructorKind.Ambiguous;
-							return null;
+							constructorKind = ConstructorKind.Default;
+							return mostRichConstructors[ 0 ];
 						}
 						else
 						{
-							throw new SerializationException(
-								String.Format(
-									CultureInfo.CurrentCulture,
-									"Cannot serialize type '{0}' because it does not have any serializable fields nor properties, and serializer generator failed to determine constructor to deserialize among({1}).",
-									targetType,
-									String.Join( ", ", mostRichConstructors.Select( ctor => ctor.ToString() ).ToArray() )
-								)
-							);
+							throw NewTypeCannotBeSerializedException( targetType );
 						}
 					}
+
+					// OK try use it but it may not handle deserialization correctly.
+					constructorKind = ConstructorKind.Parameterful;
+					return mostRichConstructors[ 0 ];
+				}
+				default:
+				{
+					if ( context.CompatibilityOptions.AllowAsymmetricSerializer )
+					{
+						constructorKind = ConstructorKind.Ambiguous;
+						return null;
+					}
+					else
+					{
+						throw new SerializationException(
+							String.Format(
+								CultureInfo.CurrentCulture,
+								"Cannot serialize type '{0}' because it does not have any serializable fields nor properties, and serializer generator failed to determine constructor to deserialize among({1}).",
+								targetType,
+								String.Join( ", ", mostRichConstructors.Select( ctor => ctor.ToString() ).ToArray() )
+							)
+						);
+					}
+				}
 			}
 		}
 
diff --git a/test/MsgPack.UnitTest/MessagePackMemberSkipTest.cs b/test/MsgPack.UnitTest/MessagePackMemberSkipTest.cs
index dd55d86b5..5cddb9065 100644
--- a/test/MsgPack.UnitTest/MessagePackMemberSkipTest.cs
+++ b/test/MsgPack.UnitTest/MessagePackMemberSkipTest.cs
@@ -27,7 +27,15 @@
 
 using MsgPack.Serialization;
 
+#if !MSTEST
 using NUnit.Framework; // For running checking
+#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
 {

From a24607dcb1270992c96e0139e1f347b2f93872b7 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 10 Sep 2018 22:04:25 +0900
Subject: [PATCH 06/36] Fix Sync.Test.json to ignore Assets/ subdirectory.

---
 Sync.Test.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Sync.Test.json b/Sync.Test.json
index 02c5272a3..2677a2afa 100644
--- a/Sync.Test.json
+++ b/Sync.Test.json
@@ -297,6 +297,7 @@
     "base": "MsgPack.UnitTest.Uwp",
     "globs": [
       {"type": "include", "path": "../../src/MsgPack/Tuple`n.cs"},
+      {"type": "remove", "path": "./Assets/**/*.cs"},
       {"type": "remove", "path": "../MsgPack.UnitTest/AssertEx.cs"},
       {"type": "remove", "path": "../MsgPack.UnitTest/gen/**/*.cs"},
       {"type": "include", "path": "../MsgPack.UnitTest/gen35/**/*.cs"}, 

From c343d15219eac0c3f757bcfc1c403ceaa9b51135 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 17:47:07 +0900
Subject: [PATCH 07/36] Synchronize projects.

---
 src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj      | 6 +++---
 .../MsgPack.Silverlight.WindowsPhone.csproj                 | 6 +++---
 src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj            | 6 +++---
 src/MsgPack.Unity/MsgPack.Unity.csproj                      | 6 +++---
 src/MsgPack.Uwp/MsgPack.Uwp.csproj                          | 6 +++---
 .../MsgPack.UnitTest.Silverlight.5.FullTrust.csproj         | 3 +++
 .../MsgPack.UnitTest.Silverlight.5.csproj                   | 3 +++
 .../MsgPack.UnitTest.Silverlight.WindowsPhone.csproj        | 3 +++
 .../MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj       | 3 +++
 .../MsgPack.UnitTest.Uwp.Aot.csproj                         | 3 +++
 test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj       | 3 +++
 .../MsgPack.UnitTest.WinRT.WindowsPhone.csproj              | 3 +++
 test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj   | 3 +++
 .../MsgPack.UnitTest.Xamarin.Android.csproj                 | 5 ++++-
 .../MsgPack.UnitTest.Xamarin.iOS.csproj                     | 3 +++
 15 files changed, 46 insertions(+), 16 deletions(-)

diff --git a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
index 45b5284a5..16e46f9da 100644
--- a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
+++ b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
@@ -245,6 +245,9 @@
     <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.ConstructorDelegate.cs">
       <Link>Serialization\ReflectionExtensions.ConstructorDelegate.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -673,9 +676,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
index 399b5796f..442277183 100644
--- a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
+++ b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
@@ -216,6 +216,9 @@
     <Compile Include="..\MsgPack\ReflectionAbstractions.cs">
       <Link>ReflectionAbstractions.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -680,9 +683,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
index 00a022cb8..e2776c167 100644
--- a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
+++ b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
@@ -220,6 +220,9 @@
     <Compile Include="..\MsgPack\Serialization\Tracer.cs">
       <Link>Serialization\Tracer.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -651,9 +654,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/src/MsgPack.Unity/MsgPack.Unity.csproj b/src/MsgPack.Unity/MsgPack.Unity.csproj
index 53ca4e7a3..3809104fe 100644
--- a/src/MsgPack.Unity/MsgPack.Unity.csproj
+++ b/src/MsgPack.Unity/MsgPack.Unity.csproj
@@ -234,13 +234,13 @@
     </Compile>
     <Compile Include="..\MsgPack\ReflectionAbstractions.cs">
       <Link>ReflectionAbstractions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\Tracer.cs">
       <Link>Serialization\Tracer.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
diff --git a/src/MsgPack.Uwp/MsgPack.Uwp.csproj b/src/MsgPack.Uwp/MsgPack.Uwp.csproj
index f32d07373..b3f453e85 100644
--- a/src/MsgPack.Uwp/MsgPack.Uwp.csproj
+++ b/src/MsgPack.Uwp/MsgPack.Uwp.csproj
@@ -244,6 +244,9 @@
     <Compile Include="..\MsgPack\ReflectionAbstractions.cs">
       <Link>ReflectionAbstractions.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -723,9 +726,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj b/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj
index ae00ef81f..d1b79c9db 100644
--- a/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj
+++ b/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj
@@ -136,6 +136,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj b/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj
index 4ec3ed4d8..68a03a547 100644
--- a/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj
+++ b/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj
@@ -121,6 +121,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj b/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj
index b799f51f8..a9c359ebe 100644
--- a/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj
+++ b/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj
@@ -99,6 +99,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj b/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj
index c32f912e9..253381245 100644
--- a/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj
+++ b/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj
@@ -442,6 +442,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
index 405c158f6..5619c491c 100644
--- a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
+++ b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
@@ -1551,6 +1551,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
index 6f5dfbce1..58e9423ca 100644
--- a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
+++ b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
@@ -1534,6 +1534,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj b/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj
index 3aca36e1c..fe28e24b0 100644
--- a/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj
+++ b/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj
@@ -122,6 +122,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
index ef2acfe77..856d1dc81 100644
--- a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
+++ b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
@@ -128,6 +128,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj b/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj
index 286251f05..26abce614 100644
--- a/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj
+++ b/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj
@@ -58,6 +58,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
@@ -263,7 +266,7 @@
   </ItemGroup>
   <ItemGroup>
     <AndroidResource Include="Resources\drawable\Icon.png" />
-    <AndroidResource Include="Resources\values\Strings.xml" >
+    <AndroidResource Include="Resources\values\Strings.xml">
       <SubType>Designer</SubType>
     </AndroidResource>
   </ItemGroup>
diff --git a/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj b/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj
index 5fb06be4c..3619a69a6 100644
--- a/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj
+++ b/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj
@@ -58,6 +58,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>

From 3dc60b6f8c4ec07874e07947a29608e8d9ea107e Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 16:48:10 +0900
Subject: [PATCH 08/36] Add SerializationCompatibilityLevel.

---
 CHANGES.txt                                   |   4 +
 .../SerializationCompatibilityLevel.cs        |  46 ++++++++
 .../Serialization/SerializationContext.cs     | 105 +++++++++++++++---
 3 files changed, 138 insertions(+), 17 deletions(-)
 create mode 100644 src/MsgPack/Serialization/SerializationCompatibilityLevel.cs

diff --git a/CHANGES.txt b/CHANGES.txt
index db2afa3b8..9dffa6710 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -761,5 +761,9 @@ Release 1.0.1 2018-09-09
 
 Release 1.1
 
+  BUG FIXES
+  * Fix conversion from DateTime[Offset] to Timestamp failure for before Unix epoc. #296 (port from 1.0.x branch)
+
   NEW FEATURE
   * Allow programatically ignoring arbitary members via BindingOptions. Thank you @ShrenikOne #282
+  * To prevent accidental Timestamp serialization in existing code, SerializationContext.ConfigureClassic(SerializationCompatibilityLevel) and SerializationContext.CreateClassicContext(SerializationCompatibilityLevel) are added. #296
diff --git a/src/MsgPack/Serialization/SerializationCompatibilityLevel.cs b/src/MsgPack/Serialization/SerializationCompatibilityLevel.cs
new file mode 100644
index 000000000..3232cf851
--- /dev/null
+++ b/src/MsgPack/Serialization/SerializationCompatibilityLevel.cs
@@ -0,0 +1,46 @@
+#region -- License Terms --
+//
+// MessagePack for CLI
+//
+// Copyright (C) 2018 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 --
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Represents compatibility level.
+	/// </summary>
+	public enum SerializationCompatibilityLevel
+	{
+		/// <summary>
+		///		Use latest feature. Almost backward compatible, but some compatibities are broken.
+		/// </summary>
+		Latest = 0,
+
+		/// <summary>
+		///		Compatible for version 0.5.x or former.
+		/// </summary>
+		Version0_5,
+
+		/// <summary>
+		///		Compatible for version 0.6.x, 0.7.x, 0.8.x, and 0.9.x.
+		/// </summary>
+		Version0_9
+	}
+}
diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index 2d33d0204..8d445eb4f 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -478,14 +478,26 @@ private MessagePackSerializer<T> OnResolveSerializer<T>( PolymorphismSchema sche
 		}
 
 		/// <summary>
-		///		Configures <see cref="Default"/> as new classic <see cref="SerializationContext"/> instance.
+		///		Configures <see cref="Default"/> as new classic <see cref="SerializationContext"/> instance as compatible for ver 0.5.
 		/// </summary>
 		/// <returns>The previously set context as <see cref="Default"/>.</returns>
 		/// <seealso cref="CreateClassicContext()"/>
+		[Obsolete( "Use ConfigureClassic(SerializationCompatibilityLevel) instead." )]
 		public static SerializationContext ConfigureClassic()
 		{
+			return ConfigureClassic( SerializationCompatibilityLevel.Version0_5 );
+		}
+
+		/// <summary>
+		///		Configures <see cref="Default"/> as new classic <see cref="SerializationContext"/> instance as compatible for sepcified version.
+		/// </summary>
+		/// <param name="compatibilityLevel">A <see cref="SerializationCompatibilityLevel"/> to specify compatibility level.</param>
+		/// <returns>The previously set context as <see cref="Default"/>.</returns>
+		/// <seealso cref="CreateClassicContext(SerializationCompatibilityLevel)"/>
+		public static SerializationContext ConfigureClassic(SerializationCompatibilityLevel compatibilityLevel)
+		{
 #if !UNITY
-			return Interlocked.Exchange( ref _default, CreateClassicContext() );
+			return Interlocked.Exchange( ref _default, CreateClassicContext( compatibilityLevel) );
 #else
 			lock ( DefaultContextSyncRoot )
 			{
@@ -502,34 +514,93 @@ public static SerializationContext ConfigureClassic()
 		/// <returns>
 		///		A new <see cref="SerializationContext"/> which is configured as same as 0.5.
 		/// </returns>
+		[Obsolete( "Use CreateClassicContext(SerializationCompatibilityLevel) instead." )]
+		public static SerializationContext CreateClassicContext()
+		{
+			return CreateClassicContext( SerializationCompatibilityLevel.Version0_5 );
+		}
+
+		/// <summary>
+		///		Creates a new <see cref="SerializationContext"/> which is configured as compatible for the specified version.
+		/// </summary>
+		/// <param name="compatibilityLevel">A <see cref="SerializationCompatibilityLevel"/> to specify compatibility level.</param>
+		/// <returns>
+		///		A new <see cref="SerializationContext"/> which is configured as compatible for the specified version.
+		/// </returns>
 		/// <remarks>
-		///		There are breaking changes of <see cref="SerializationContext"/> properties to improve API usability and to prevent accidental failure.
-		///		This method returns a <see cref="SerializationContext"/> which configured as classic style settings as follows:
+		///		<para>
+		///			There are breaking changes of <see cref="SerializationContext"/> properties to improve API usability and to prevent accidental failure.
+		///			This method returns a <see cref="SerializationContext"/> which configured as classic style settings as follows:
+		///		</para>
 		///		<list type="table">
 		///			<listheader>
 		///				<term></term>
-		///				<description>Default (as of 0.6)</description>
-		///				<description>Classic (before 0.6)</description>
+		///				<description>Latest (as of 0.6)</description>
+		///				<description>Version0_9 (as of 0.6)</description>
+		///				<description>Version0_5 (formally, "classic", before 0.6)</description>
 		///			</listheader>
 		///			<item>
-		///				<term>Packed object members order (if members are not marked with <see cref="MessagePackMemberAttribute"/>  nor <c>System.Runtime.Serialization.DataMemberAttribute</c> and serializer uses <see cref="F:SerializationMethod.Array"/>)</term>
-		///				<description>As declared (metadata table order)</description>
-		///				<description>As lexicographical</description>
-		///			</item>
-		///			<item>
-		///				<term><see cref="DateTime"/> value</term>
+		///				<term><see cref="DateTime"/> and <see cref="DateTimeOffset"/> value</term>
+		///				<description><see cref="Timestamp"/> value.</description>
 		///				<description>Native representation (100-nano ticks, preserving <see cref="DateTimeKind"/>.)</description>
 		///				<description>UTC, milliseconds Unix epoc.</description>
 		///			</item>
+		///			<item>
+		///				<term>Usage of <c>ext</c> types</term>
+		///				<description>Allowed</description>
+		///				<description>Allowed</description>
+		///				<description>Prohibited</description>
+		///			</item>
+		///			<item>
+		///				<term>Binary (such as <c>Byte[]</c>) representation</term>
+		///				<description>Bin types</description>
+		///				<description>Bin types</description>
+		///				<description>Raw types</description>
+		///			</item>
+		///			<item>
+		///				<term>Strings which lengthes are between 17 to 255</term>
+		///				<description>Str8 type</description>
+		///				<description>Str8 types</description>
+		///				<description>Raw16 type</description>
+		///			</item>
 		///		</list>
+		///		<para>
+		///			In short, <see cref="SerializationCompatibilityLevel.Version0_5"/> prohibits deserialization error in legacy implementation
+		///			which do not recognize ext types, str8 type, and/or bin types.
+		///			<see cref="SerializationCompatibilityLevel.Version0_9"/> prohibits only <see cref="Timestamp"/> serialization for datetime
+		///			to keep compatibility for 0.9.x instead of maximize datetime serialization for modern implementations which uses msgpack timestamp type,
+		///			which is composite ext type, nano-second precision Unix epoc time.
+		///		</para>
 		/// </remarks>
-		public static SerializationContext CreateClassicContext()
+		public static SerializationContext CreateClassicContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			return
-				new SerializationContext( PackerCompatibilityOptions.Classic )
+			switch ( compatibilityLevel )
+			{
+				case SerializationCompatibilityLevel.Version0_5:
 				{
-					DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc
-				};
+					return
+						new SerializationContext( PackerCompatibilityOptions.Classic )
+						{
+							DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc
+						};
+				}
+				case SerializationCompatibilityLevel.Version0_9:
+				{
+					return
+						new SerializationContext( PackerCompatibilityOptions.None )
+						{
+							DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native
+						};
+				}
+				case SerializationCompatibilityLevel.Latest:
+				{
+					return new SerializationContext( PackerCompatibilityOptions.None );
+				}
+				default:
+				{
+					throw new ArgumentOutOfRangeException( "Unknown SerializationCompatibilityLevel value." );
+				}
+			}
 		}
 
 		/// <summary>

From c3b63c008a8039057a694d19ce871f64c8013728 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 17:47:21 +0900
Subject: [PATCH 09/36] Synchronize projects.

---
 src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj         | 3 +++
 .../MsgPack.Silverlight.WindowsPhone.csproj                    | 3 +++
 src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj               | 3 +++
 src/MsgPack.Unity/MsgPack.Unity.csproj                         | 3 +++
 src/MsgPack.Uwp/MsgPack.Uwp.csproj                             | 3 +++
 5 files changed, 15 insertions(+)

diff --git a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
index 16e46f9da..f8d9dc0c1 100644
--- a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
+++ b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
@@ -674,6 +674,9 @@
     <Compile Include="..\MsgPack\Serialization\ResolveSerializerEventArgs.cs">
       <Link>Serialization\ResolveSerializerEventArgs.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityLevel.cs">
+      <Link>Serialization\SerializationCompatibilityLevel.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
     </Compile>
diff --git a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
index 442277183..13939a92b 100644
--- a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
+++ b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
@@ -681,6 +681,9 @@
     <Compile Include="..\MsgPack\Serialization\ResolveSerializerEventArgs.cs">
       <Link>Serialization\ResolveSerializerEventArgs.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityLevel.cs">
+      <Link>Serialization\SerializationCompatibilityLevel.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
     </Compile>
diff --git a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
index e2776c167..c7665009a 100644
--- a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
+++ b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
@@ -652,6 +652,9 @@
     <Compile Include="..\MsgPack\Serialization\ResolveSerializerEventArgs.cs">
       <Link>Serialization\ResolveSerializerEventArgs.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityLevel.cs">
+      <Link>Serialization\SerializationCompatibilityLevel.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
     </Compile>
diff --git a/src/MsgPack.Unity/MsgPack.Unity.csproj b/src/MsgPack.Unity/MsgPack.Unity.csproj
index 3809104fe..8d8d7361f 100644
--- a/src/MsgPack.Unity/MsgPack.Unity.csproj
+++ b/src/MsgPack.Unity/MsgPack.Unity.csproj
@@ -658,6 +658,9 @@
     <Compile Include="..\MsgPack\Serialization\ResolveSerializerEventArgs.cs">
       <Link>Serialization\ResolveSerializerEventArgs.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityLevel.cs">
+      <Link>Serialization\SerializationCompatibilityLevel.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
     </Compile>
diff --git a/src/MsgPack.Uwp/MsgPack.Uwp.csproj b/src/MsgPack.Uwp/MsgPack.Uwp.csproj
index b3f453e85..6865b97e6 100644
--- a/src/MsgPack.Uwp/MsgPack.Uwp.csproj
+++ b/src/MsgPack.Uwp/MsgPack.Uwp.csproj
@@ -724,6 +724,9 @@
     <Compile Include="..\MsgPack\Serialization\ResolveSerializerEventArgs.cs">
       <Link>Serialization\ResolveSerializerEventArgs.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityLevel.cs">
+      <Link>Serialization\SerializationCompatibilityLevel.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
     </Compile>

From fcc15726ffd20b8a3abc162b1036ac982a1a7207 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 17:27:10 +0900
Subject: [PATCH 10/36] Add/fix unit tests to test compatibility levels
 correctly.

---
 ...deDomBasedAutoMessagePackSerializerTest.cs | 127 ++++++++++++++---
 ...deDomBasedAutoMessagePackSerializerTest.cs | 127 ++++++++++++++---
 ...FieldBasedAutoMessagePackSerializerTest.cs | 127 ++++++++++++++---
 ...ationBasedAutoMessagePackSerializerTest.cs |  90 ++++++++++--
 ...ctionBasedAutoMessagePackSerializerTest.cs | 127 ++++++++++++++---
 .../AutoMessagePackSerializerTest.ttinclude   | 129 +++++++++++++++---
 ...FieldBasedAutoMessagePackSerializerTest.cs | 127 ++++++++++++++---
 ...ationBasedAutoMessagePackSerializerTest.cs |  90 ++++++++++--
 ...ctionBasedAutoMessagePackSerializerTest.cs | 127 ++++++++++++++---
 .../PreGeneratedSerializerActivator.cs        |  24 +++-
 .../Serialization/RegressionTests.cs          |   2 +-
 .../Serialization/SerializationContextTest.cs |  81 +++++++++--
 .../TimestampSerializationTest.cs             |  12 +-
 13 files changed, 1005 insertions(+), 185 deletions(-)

diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs
index 65f18287a..574d83dca 100644
--- a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs
@@ -92,13 +92,13 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Array };
-			context.DefaultDateTimeConversionMethod = dateTimeConversionMethod;
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = SerializationMethod.Array;
 			context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeDomBased;
 #if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
 			context.SerializerOptions.DisablePrivilegedAccess = true;
@@ -278,10 +278,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		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,
+				DateTime.Now, // Use now because Native mode should serialize its kind
 				stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ),
 				( x, y ) => x.Equals( y ),
 				context =>
@@ -292,10 +320,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -310,7 +338,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -324,7 +352,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -1468,7 +1496,8 @@ private async Task TestTupleAsyncCore<T>( T expected, int arity )
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -1479,9 +1508,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -1492,6 +1521,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -4380,10 +4423,10 @@ public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed()
 #endif // FEATURE_TAP
 
 		[Test]
-		public void TestBinary_ClassicContext()
+		public void TestBinary_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
-			var serializer = context.GetSerializer<byte[]>();
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
 			{
@@ -4392,10 +4435,37 @@ public void TestBinary_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestBinary_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );;
+			}
+		}
+
+		[Test]
+		public void TestBinary_DefaultContext()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );
+			}
+		}
+
 		[Test]
 		public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None;
 			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
@@ -4405,9 +4475,9 @@ public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 			}
 		}
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -4421,10 +4491,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs
index f7e10d905..0830279d3 100644
--- a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs
@@ -93,13 +93,13 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Map };
-			context.DefaultDateTimeConversionMethod = dateTimeConversionMethod;
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = SerializationMethod.Map;
 			context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeDomBased;
 #if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
 			context.SerializerOptions.DisablePrivilegedAccess = true;
@@ -279,10 +279,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		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,
+				DateTime.Now, // Use now because Native mode should serialize its kind
 				stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ),
 				( x, y ) => x.Equals( y ),
 				context =>
@@ -293,10 +321,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -311,7 +339,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -325,7 +353,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -1469,7 +1497,8 @@ private async Task TestTupleAsyncCore<T>( T expected, int arity )
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -1480,9 +1509,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -1493,6 +1522,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -4457,10 +4500,10 @@ public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed()
 #endif // FEATURE_TAP
 
 		[Test]
-		public void TestBinary_ClassicContext()
+		public void TestBinary_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
-			var serializer = context.GetSerializer<byte[]>();
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
 			{
@@ -4469,10 +4512,37 @@ public void TestBinary_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestBinary_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );;
+			}
+		}
+
+		[Test]
+		public void TestBinary_DefaultContext()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );
+			}
+		}
+
 		[Test]
 		public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None;
 			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
@@ -4482,9 +4552,9 @@ public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 			}
 		}
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -4498,10 +4568,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs
index 9fe454b99..d46157954 100644
--- a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs
@@ -92,13 +92,13 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Array };
-			context.DefaultDateTimeConversionMethod = dateTimeConversionMethod;
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = SerializationMethod.Array;
 			context.SerializerOptions.EmitterFlavor = EmitterFlavor.FieldBased;
 #if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
 			context.SerializerOptions.DisablePrivilegedAccess = true;
@@ -278,10 +278,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		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,
+				DateTime.Now, // Use now because Native mode should serialize its kind
 				stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ),
 				( x, y ) => x.Equals( y ),
 				context =>
@@ -292,10 +320,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -310,7 +338,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -324,7 +352,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -1468,7 +1496,8 @@ private async Task TestTupleAsyncCore<T>( T expected, int arity )
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -1479,9 +1508,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -1492,6 +1521,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -4380,10 +4423,10 @@ public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed()
 #endif // FEATURE_TAP
 
 		[Test]
-		public void TestBinary_ClassicContext()
+		public void TestBinary_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
-			var serializer = context.GetSerializer<byte[]>();
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
 			{
@@ -4392,10 +4435,37 @@ public void TestBinary_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestBinary_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );;
+			}
+		}
+
+		[Test]
+		public void TestBinary_DefaultContext()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );
+			}
+		}
+
 		[Test]
 		public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None;
 			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
@@ -4405,9 +4475,9 @@ public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 			}
 		}
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -4421,10 +4491,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs
index 3b2e72e92..017eaba9a 100644
--- a/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs
@@ -92,12 +92,12 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context =  PreGeneratedSerializerActivator.CreateContext( SerializationMethod.Array, compatibilityOptions );
+			var context =  PreGeneratedSerializerActivator.CreateContext( SerializationMethod.Array, compatibilityLevel );
 			// Register serializers for abstract class testing
 			context.Serializers.Register( 
 				new EchoKeyedCollection_2MessagePackSerializer<string, string>( context, null ) 
@@ -204,10 +204,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		public void TestDateTimeLatest()
 		{
 			TestCore(
-				DateTime.Now,
+				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 =>
@@ -218,10 +246,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -236,7 +264,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -250,7 +278,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -573,7 +601,8 @@ public void TestCharArrayContent()
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -584,9 +613,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -597,6 +626,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -1021,9 +1064,9 @@ public void TestIDictionaryValueType_Success()
 		}
 
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -1037,10 +1080,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs
index c4a01a855..91c43e82e 100644
--- a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs
@@ -92,13 +92,13 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Array };
-			context.DefaultDateTimeConversionMethod = dateTimeConversionMethod;
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = SerializationMethod.Array;
 			context.SerializerOptions.EmitterFlavor = EmitterFlavor.ReflectionBased;
 #if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
 			context.SerializerOptions.DisablePrivilegedAccess = true;
@@ -278,10 +278,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		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,
+				DateTime.Now, // Use now because Native mode should serialize its kind
 				stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ),
 				( x, y ) => x.Equals( y ),
 				context =>
@@ -292,10 +320,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -310,7 +338,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -324,7 +352,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -1468,7 +1496,8 @@ private async Task TestTupleAsyncCore<T>( T expected, int arity )
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -1479,9 +1508,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -1492,6 +1521,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -4380,10 +4423,10 @@ public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed()
 #endif // FEATURE_TAP
 
 		[Test]
-		public void TestBinary_ClassicContext()
+		public void TestBinary_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
-			var serializer = context.GetSerializer<byte[]>();
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
 			{
@@ -4392,10 +4435,37 @@ public void TestBinary_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestBinary_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );;
+			}
+		}
+
+		[Test]
+		public void TestBinary_DefaultContext()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );
+			}
+		}
+
 		[Test]
 		public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None;
 			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
@@ -4405,9 +4475,9 @@ public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 			}
 		}
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -4421,10 +4491,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude
index 6f1d80413..8a00a2592 100644
--- a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude
+++ b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude
@@ -150,17 +150,17 @@ namespace MsgPack.Serialization
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
 <#+
 	if ( !forIos )
 	{
 #>
-			var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.<#= serializationMethod #> };
-			context.DefaultDateTimeConversionMethod = dateTimeConversionMethod;
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = SerializationMethod.<#= serializationMethod #>;
 			context.SerializerOptions.EmitterFlavor = EmitterFlavor.<#= emitterFlavor #>;
 #if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
 			context.SerializerOptions.DisablePrivilegedAccess = true;
@@ -171,7 +171,7 @@ namespace MsgPack.Serialization
 	else
 	{
 #>
-			var context =  PreGeneratedSerializerActivator.CreateContext( SerializationMethod.Array, compatibilityOptions );
+			var context =  PreGeneratedSerializerActivator.CreateContext( SerializationMethod.Array, compatibilityLevel );
 			// Register serializers for abstract class testing
 			context.Serializers.Register( 
 				new EchoKeyedCollection_2MessagePackSerializer<string, string>( context, null ) 
@@ -370,10 +370,38 @@ namespace MsgPack.Serialization
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		public void TestDateTimeLatest()
 		{
 			TestCore(
-				DateTime.Now,
+				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 =>
@@ -384,10 +412,10 @@ namespace MsgPack.Serialization
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -402,7 +430,7 @@ namespace MsgPack.Serialization
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -416,7 +444,7 @@ namespace MsgPack.Serialization
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -1517,7 +1545,8 @@ namespace MsgPack.Serialization
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -1528,9 +1557,9 @@ namespace MsgPack.Serialization
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -1541,6 +1570,20 @@ namespace MsgPack.Serialization
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -2600,10 +2643,10 @@ namespace MsgPack.Serialization
 #endif // FEATURE_TAP
 
 		[Test]
-		public void TestBinary_ClassicContext()
+		public void TestBinary_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
-			var serializer = context.GetSerializer<byte[]>();
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
 			{
@@ -2612,10 +2655,37 @@ namespace MsgPack.Serialization
 			}
 		}
 
+		[Test]
+		public void TestBinary_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );;
+			}
+		}
+
+		[Test]
+		public void TestBinary_DefaultContext()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );
+			}
+		}
+
 		[Test]
 		public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None;
 			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
@@ -2628,9 +2698,9 @@ namespace MsgPack.Serialization
 	}
 #>
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -2644,10 +2714,27 @@ namespace MsgPack.Serialization
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs
index 80af2f0c9..70a4e2fa9 100644
--- a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs
@@ -93,13 +93,13 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Map };
-			context.DefaultDateTimeConversionMethod = dateTimeConversionMethod;
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = SerializationMethod.Map;
 			context.SerializerOptions.EmitterFlavor = EmitterFlavor.FieldBased;
 #if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
 			context.SerializerOptions.DisablePrivilegedAccess = true;
@@ -279,10 +279,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		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,
+				DateTime.Now, // Use now because Native mode should serialize its kind
 				stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ),
 				( x, y ) => x.Equals( y ),
 				context =>
@@ -293,10 +321,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -311,7 +339,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -325,7 +353,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -1469,7 +1497,8 @@ private async Task TestTupleAsyncCore<T>( T expected, int arity )
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -1480,9 +1509,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -1493,6 +1522,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -4457,10 +4500,10 @@ public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed()
 #endif // FEATURE_TAP
 
 		[Test]
-		public void TestBinary_ClassicContext()
+		public void TestBinary_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
-			var serializer = context.GetSerializer<byte[]>();
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
 			{
@@ -4469,10 +4512,37 @@ public void TestBinary_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestBinary_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );;
+			}
+		}
+
+		[Test]
+		public void TestBinary_DefaultContext()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );
+			}
+		}
+
 		[Test]
 		public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None;
 			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
@@ -4482,9 +4552,9 @@ public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 			}
 		}
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -4498,10 +4568,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs
index 1ed3ee3dd..4dc4485b9 100644
--- a/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs
@@ -92,12 +92,12 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context =  PreGeneratedSerializerActivator.CreateContext( SerializationMethod.Array, compatibilityOptions );
+			var context =  PreGeneratedSerializerActivator.CreateContext( SerializationMethod.Array, compatibilityLevel );
 			// Register serializers for abstract class testing
 			context.Serializers.Register( 
 				new EchoKeyedCollection_2MessagePackSerializer<string, string>( context, null ) 
@@ -204,10 +204,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		public void TestDateTimeLatest()
 		{
 			TestCore(
-				DateTime.Now,
+				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 =>
@@ -218,10 +246,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -236,7 +264,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -250,7 +278,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -573,7 +601,8 @@ public void TestCharArrayContent()
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -584,9 +613,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -597,6 +626,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -1021,9 +1064,9 @@ public void TestIDictionaryValueType_Success()
 		}
 
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -1037,10 +1080,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs
index 2fbeb31fb..6a694ebe0 100644
--- a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs
@@ -93,13 +93,13 @@ private static SerializationContext GetSerializationContext()
 
 		private static SerializationContext NewSerializationContext()
 		{
-			return NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			return NewSerializationContext( SerializationCompatibilityLevel.Latest );
 		}
 
-		private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions, DateTimeConversionMethod dateTimeConversionMethod )
+		private static SerializationContext NewSerializationContext( SerializationCompatibilityLevel compatibilityLevel )
 		{
-			var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Map };
-			context.DefaultDateTimeConversionMethod = dateTimeConversionMethod;
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = SerializationMethod.Map;
 			context.SerializerOptions.EmitterFlavor = EmitterFlavor.ReflectionBased;
 #if SILVERLIGHT && !SILVERLIGHT_PRIVILEGED
 			context.SerializerOptions.DisablePrivilegedAccess = true;
@@ -279,10 +279,38 @@ public void TestDateTimeOffset()
 		}
 
 		[Test]
-		public void TestDateTimeNative()
+		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,
+				DateTime.Now, // Use now because Native mode should serialize its kind
 				stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ),
 				( x, y ) => x.Equals( y ),
 				context =>
@@ -293,10 +321,10 @@ public void TestDateTimeNative()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetNative()
+		public void TestDateTimeOffsetClassic0_9()
 		{
 			TestCore(
-				DateTimeOffset.Now,
+				DateTimeOffset.Now, // Use now because Native mode should serialize its kind
 				stream => 
 					{
 						var array = Unpacking.UnpackArray( stream );
@@ -311,7 +339,7 @@ public void TestDateTimeOffsetNative()
 		}
 
 		[Test]
-		public void TestDateTimeClassic()
+		public void TestDateTimeClassic0_5()
 		{
 			TestCore(
 				DateTime.UtcNow,
@@ -325,7 +353,7 @@ public void TestDateTimeClassic()
 		}
 
 		[Test]
-		public void TestDateTimeOffsetClassic()
+		public void TestDateTimeOffsetClassic0_5()
 		{
 			TestCore(
 				DateTimeOffset.UtcNow,
@@ -1469,7 +1497,8 @@ private async Task TestTupleAsyncCore<T>( T expected, int arity )
 		[Test]
 		public void TestEmptyBytes()
 		{
-			var serializer = this.CreateTarget<byte[]>( GetSerializationContext() );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
 				serializer.Pack( stream, new byte[ 0 ] );
@@ -1480,9 +1509,9 @@ public void TestEmptyBytes()
 		}
 
 		[Test]
-		public void TestEmptyBytes_Classic()
+		public void TestEmptyBytes_Classic0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			var serializer = this.CreateTarget<byte[]>( context );
 			using ( var stream = new MemoryStream() )
 			{
@@ -1493,6 +1522,20 @@ public void TestEmptyBytes_Classic()
 			}
 		}
 
+		[Test]
+		public void TestEmptyBytes_Classic0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = this.CreateTarget<byte[]>( context );
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[ 0 ] );
+				Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) );
+				stream.Position = 0;
+				Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) );
+			}
+		}
+
 		[Test]
 		public void TestEmptyString()
 		{
@@ -4457,10 +4500,10 @@ public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed()
 #endif // FEATURE_TAP
 
 		[Test]
-		public void TestBinary_ClassicContext()
+		public void TestBinary_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.Classic, DateTimeConversionMethod.Native );
-			var serializer = context.GetSerializer<byte[]>();
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
 			{
@@ -4469,10 +4512,37 @@ public void TestBinary_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestBinary_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );;
+			}
+		}
+
+		[Test]
+		public void TestBinary_DefaultContext()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
+			var serializer = CreateTarget<byte[]>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				serializer.Pack( stream, new byte[] { 1 } );
+				Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) );
+			}
+		}
+
 		[Test]
 		public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 		{
-			var context = NewSerializationContext( PackerCompatibilityOptions.None, DateTimeConversionMethod.Timestamp );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
+			context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None;
 			var serializer = CreateTarget<byte[]>( context );
 
 			using ( var stream = new MemoryStream() )
@@ -4482,9 +4552,9 @@ public void TestBinary_ContextWithPackerCompatilibyOptionsNone()
 			}
 		}
 		[Test]
-		public void TestExt_ClassicContext()
+		public void TestExt_ClassicContext0_5()
 		{
-			var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.CreateClassicContext().DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 );
 			context.Serializers.RegisterOverride( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
@@ -4498,10 +4568,27 @@ public void TestExt_ClassicContext()
 			}
 		}
 
+		[Test]
+		public void TestExt_ClassicContext0_9()
+		{
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_9 );
+			context.Serializers.Register( new CustomDateTimeSerealizer() );
+			var serializer = CreateTarget<DateTime>( context );
+
+			using ( var stream = new MemoryStream() )
+			{
+				var date = DateTime.UtcNow;
+				serializer.Pack( stream, date );
+				stream.Position = 0;
+				var unpacked = serializer.Unpack( stream );
+				Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) );
+			}
+		}
+
 		[Test]
 		public void TestExt_DefaultContext()
 		{
-			var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, SerializationContext.Default.DefaultDateTimeConversionMethod );
+			var context = NewSerializationContext( SerializationCompatibilityLevel.Latest );
 			context.Serializers.Register( new CustomDateTimeSerealizer() );
 			var serializer = CreateTarget<DateTime>( context );
 
diff --git a/test/MsgPack.UnitTest/Serialization/PreGeneratedSerializerActivator.cs b/test/MsgPack.UnitTest/Serialization/PreGeneratedSerializerActivator.cs
index f091126da..199f0d883 100644
--- a/test/MsgPack.UnitTest/Serialization/PreGeneratedSerializerActivator.cs
+++ b/test/MsgPack.UnitTest/Serialization/PreGeneratedSerializerActivator.cs
@@ -1,4 +1,4 @@
-#region -- License Terms --
+#region -- License Terms --
 //
 // MessagePack for CLI
 //
@@ -105,6 +105,28 @@ public static SerializationContext CreateContext( SerializationMethod method, Pa
 				context.Serializers.Register( entry.Key, entry.Value, null, null, SerializerRegistrationOptions.None );
 			}
 
+#if !AOT
+			context.SerializerOptions.DisableRuntimeCodeGeneration = true;
+#endif // !AOT
+			return context;
+		}
+
+		/// <summary>
+		///		Creates new <see cref="SerializationContext"/> for generation based testing.
+		/// </summary>
+		/// <param name="method"><see cref="SerializationMethod"/>.</param>
+		/// <param name="compatibilityLevel"><see cref="SerializationCompatibilityLevel"/> for built-in serializers.</param>
+		/// <returns>A new <see cref="SerializationContext"/> for generation based testing.</returns>
+		public static SerializationContext CreateContext( SerializationMethod method, SerializationCompatibilityLevel compatibilityLevel )
+		{
+			var context = SerializationContext.CreateClassicContext( compatibilityLevel );
+			context.SerializationMethod = method;
+
+			foreach ( var entry in _serializers )
+			{
+				context.Serializers.Register( entry.Key, entry.Value, null, null, SerializerRegistrationOptions.None );
+			}
+
 #if !AOT
 			context.SerializerOptions.DisableRuntimeCodeGeneration = true;
 #endif // !AOT
diff --git a/test/MsgPack.UnitTest/Serialization/RegressionTests.cs b/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
index 65bdf4434..ed4cad3ac 100644
--- a/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
+++ b/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
@@ -83,7 +83,7 @@ public void TestIssue70()
 		[Test]
 		public void TestIssue73()
 		{
-			var original = SerializationContext.ConfigureClassic();
+			var original = SerializationContext.ConfigureClassic( SerializationCompatibilityLevel.Version0_5 );
 			try
 			{
 				var value =
diff --git a/test/MsgPack.UnitTest/Serialization/SerializationContextTest.cs b/test/MsgPack.UnitTest/Serialization/SerializationContextTest.cs
index ded981b53..003396651 100644
--- a/test/MsgPack.UnitTest/Serialization/SerializationContextTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/SerializationContextTest.cs
@@ -2,7 +2,7 @@
 //
 // MessagePack for CLI
 //
-// Copyright (C) 2010-2017 FUJIWARA, Yusuke
+// Copyright (C) 2010-2018 FUJIWARA, Yusuke
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -213,11 +213,12 @@ public void TestDefault_SafeAndEasySettings()
 		}
 
 		[Test]
-		public void TestCreateClassicContext_Version0_5_Compatible()
+		public void TestCreateClassicContext_Version0_5_Version0_5_Compatible()
 		{
-			var context = SerializationContext.CreateClassicContext();
+			var context = SerializationContext.CreateClassicContext( SerializationCompatibilityLevel.Version0_5 );
 			Assert.That( context, Is.Not.Null );
 			Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.UnixEpoc ) );
+			Assert.That( context.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.Classic ) );
 			Assert.That( context.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
 #if !AOT && !UNITY && !SILVERLIGHT
 			Assert.That( context.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
@@ -226,27 +227,29 @@ public void TestCreateClassicContext_Version0_5_Compatible()
 		}
 
 		[Test]
-		public void TestConfigureClassic_DefaultIsReplaced()
+		public void TestConfigureClassic_Version0_5_DefaultIsReplaced()
 		{
 			var previous = SerializationContext.Default;
 			try
 			{
-				var result = SerializationContext.ConfigureClassic();
+				var result = SerializationContext.ConfigureClassic( SerializationCompatibilityLevel.Version0_5 );
 
 				// result is old.
 				Assert.That( result, Is.SameAs( previous ) );
 				// result is default settings.
 				Assert.That( result, Is.Not.Null );
 				Assert.That( result.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Timestamp ) );
+				Assert.That( result.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.None ) );
 				Assert.That( result.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
 #if !AOT && !UNITY && !SILVERLIGHT
 				Assert.That( result.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
 #endif // !AOT && !UNITY && !SILVERLIGHT
 				Assert.That( result.SerializationMethod, Is.EqualTo( SerializationMethod.Array ) );
 
-				// default is now classic
+				// default is now classic 0.5
 				Assert.That( SerializationContext.Default, Is.Not.Null );
 				Assert.That( SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.UnixEpoc ) );
+				Assert.That( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.Classic ) );
 				Assert.That( SerializationContext.Default.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
 #if !AOT && !UNITY && !SILVERLIGHT
 				Assert.That( SerializationContext.Default.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
@@ -260,6 +263,66 @@ public void TestConfigureClassic_DefaultIsReplaced()
 
 			// Verify restore
 			Assert.That( SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Timestamp ) );
+			Assert.That( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.None ) );
+			Assert.That( SerializationContext.Default.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
+#if !AOT && !UNITY && !SILVERLIGHT
+			Assert.That( SerializationContext.Default.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
+#endif // !AOT && !UNITY && !SILVERLIGHT
+			Assert.That( SerializationContext.Default.SerializationMethod, Is.EqualTo( SerializationMethod.Array ) );
+		}
+
+		[Test]
+		public void TestCreateClassicContext_Version0_9_Version0_9_Compatible()
+		{
+			var context = SerializationContext.CreateClassicContext( SerializationCompatibilityLevel.Version0_9 );
+			Assert.That( context, Is.Not.Null );
+			Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) );
+			Assert.That( context.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.None ) );
+			Assert.That( context.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
+#if !AOT && !UNITY && !SILVERLIGHT
+			Assert.That( context.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
+#endif // !AOT && !UNITY && !SILVERLIGHT
+			Assert.That( context.SerializationMethod, Is.EqualTo( SerializationMethod.Array ) );
+		}
+
+		[Test]
+		public void TestConfigureClassic_Version0_9_DefaultIsReplaced()
+		{
+			var previous = SerializationContext.Default;
+			try
+			{
+				var result = SerializationContext.ConfigureClassic( SerializationCompatibilityLevel.Version0_9 );
+
+				// result is old.
+				Assert.That( result, Is.SameAs( previous ) );
+				// result is default settings.
+				Assert.That( result, Is.Not.Null );
+				Assert.That( result.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Timestamp ) );
+				Assert.That( result.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.None ) );
+				Assert.That( result.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
+#if !AOT && !UNITY && !SILVERLIGHT
+				Assert.That( result.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
+#endif // !AOT && !UNITY && !SILVERLIGHT
+				Assert.That( result.SerializationMethod, Is.EqualTo( SerializationMethod.Array ) );
+
+				// default is now classic 0.9
+				Assert.That( SerializationContext.Default, Is.Not.Null );
+				Assert.That( SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) );
+				Assert.That( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.None ) );
+				Assert.That( SerializationContext.Default.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
+#if !AOT && !UNITY && !SILVERLIGHT
+				Assert.That( SerializationContext.Default.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
+#endif // !AOT && !UNITY && !SILVERLIGHT
+				Assert.That( SerializationContext.Default.SerializationMethod, Is.EqualTo( SerializationMethod.Array ) );
+			}
+			finally
+			{
+				SerializationContext.Default = previous;
+			}
+
+			// Verify restore
+			Assert.That( SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Timestamp ) );
+			Assert.That( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo( PackerCompatibilityOptions.None ) );
 			Assert.That( SerializationContext.Default.EnumSerializationOptions.SerializationMethod, Is.EqualTo( EnumSerializationMethod.ByName ) );
 #if !AOT && !UNITY && !SILVERLIGHT
 			Assert.That( SerializationContext.Default.SerializerOptions.GeneratorOption, Is.EqualTo( SerializationMethodGeneratorOption.Fast ) );
@@ -289,7 +352,7 @@ public void TestIssue27_Dictionary()
 			var context = new SerializationContext();
 			using ( var buffer = new MemoryStream() )
 			{
-				var serializer = context.GetSerializer<IDictionary<String, String>>();
+				var serializer = context.GetSerializer<IDictionary<string, string>>();
 				var dic = new Dictionary<string, string> { { "A", "A" } };
 				serializer.Pack( buffer, dic );
 				buffer.Position = 0;
@@ -307,7 +370,7 @@ public void TestIssue27_List()
 			var context = new SerializationContext();
 			using ( var buffer = new MemoryStream() )
 			{
-				var serializer = context.GetSerializer<IList<String>>();
+				var serializer = context.GetSerializer<IList<string>>();
 				var list = new List<string> { "A" };
 				serializer.Pack( buffer, list );
 				buffer.Position = 0;
@@ -619,7 +682,7 @@ public sealed class NewConcreteCollection<T> : NewAbstractCollection<T>
 		{
 		}
 
-		private sealed class StringKeyDictionary<T> : Dictionary<String, T>
+		private sealed class StringKeyDictionary<T> : Dictionary<string, T>
 		{
 		}
 
diff --git a/test/MsgPack.UnitTest/Serialization/TimestampSerializationTest.cs b/test/MsgPack.UnitTest/Serialization/TimestampSerializationTest.cs
index 2c5314f6a..8e1b6b269 100644
--- a/test/MsgPack.UnitTest/Serialization/TimestampSerializationTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/TimestampSerializationTest.cs
@@ -151,15 +151,21 @@ private static void TestSerializationCore( SerializationContext context, DateTim
 		}
 
 		[Test]
-		public void TestSerialization_DefaultTimestamp()
+		public void TestSerialization_Default_Timestamp()
 		{
 			TestSerializationCore( new SerializationContext(), DateTimeConversionMethod.Timestamp );
 		}
 
 		[Test]
-		public void TestSerialization_ClassicUnixEpoc()
+		public void TestSerialization_Classic0_5_UnixEpoc()
 		{
-			TestSerializationCore( SerializationContext.CreateClassicContext(), DateTimeConversionMethod.UnixEpoc );
+			TestSerializationCore( SerializationContext.CreateClassicContext( SerializationCompatibilityLevel.Version0_5 ), DateTimeConversionMethod.UnixEpoc );
+		}
+
+		[Test]
+		public void TestSerialization_Classic0_9_Native()
+		{
+			TestSerializationCore( SerializationContext.CreateClassicContext( SerializationCompatibilityLevel.Version0_9 ), DateTimeConversionMethod.Native );
 		}
 
 		[Test]

From 23dd3624f97f6db970aba4f3e650f4afccfc2e99 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 21:20:40 +0900
Subject: [PATCH 11/36] Fix CI settings to run release build on patching
 branches for future.

---
 appveyor-release.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/appveyor-release.yml b/appveyor-release.yml
index b763baea5..49dca6f53 100644
--- a/appveyor-release.yml
+++ b/appveyor-release.yml
@@ -3,9 +3,7 @@ image: Visual Studio 2017
 branches:
   only:
   - master
-  - 0.7
-  - 0.8
-  - 0.9
+  - /[0-9]+\.[0-9]+(\.[xX])?/
 configuration: Release
 assembly_info:
   patch: true

From b7ff7d2acb8adbeb3d30e5b72d147e267cbd81f9 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 9 Sep 2018 22:47:40 +0900
Subject: [PATCH 12/36] Fix build script to generate symbol package correctly.

---
 build/Build.ps1 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/Build.ps1 b/build/Build.ps1
index 8f4e35827..c397399b9 100644
--- a/build/Build.ps1
+++ b/build/Build.ps1
@@ -158,7 +158,7 @@ if ( $buildConfig -eq 'Release' )
 {
 	Write-Host "Build NuGet packages..."
 
-	& $msbuild ../src/MsgPack/MsgPack.csproj /t:pack /v:minimal /p:Configuration=$buildConfig /p:IncludeSource=true /p:NuspecProperties=version=$env:PackageVersion
+	& $msbuild ../src/MsgPack/MsgPack.csproj /t:pack /v:minimal /p:Configuration=$buildConfig /p:IncludeSource=true /p:IncludeSymbols=true /p:NuspecProperties=version=$env:PackageVersion
 
 	Move-Item ../bin/*.nupkg ../dist/
 	Copy-Item ../bin/* ./MsgPack-CLI/ -Recurse -Exclude @("*.vshost.*")

From 883db14ca271b7a7af09b69b628a84e7468572f0 Mon Sep 17 00:00:00 2001
From: shimat <schimatk@gmail.com>
Date: Tue, 30 Oct 2018 14:09:55 +0900
Subject: [PATCH 13/36] fix serlaization typo?

---
 ...Sample03_SerializationContextAndOptions.cs |  6 ++---
 .../SerializerBuilder`2.Object.cs             |  6 ++---
 .../DictionaryKeyTransformers.cs              |  2 +-
 ...s.cs => DictionarySerializationOptions.cs} |  6 ++---
 .../Serialization/MessagePackSerializer`1.cs  |  6 ++---
 src/MsgPack/Serialization/PackHelpers.cs      |  4 +--
 ...ReflectionObjectMessagePackSerializer`1.cs | 14 +++++-----
 .../Serialization/SerializationContext.cs     | 10 +++----
 ...deDomBasedAutoMessagePackSerializerTest.cs | 24 ++++++++---------
 .../AutoMessagePackSerializerTest.ttinclude   | 24 ++++++++---------
 ...FieldBasedAutoMessagePackSerializerTest.cs | 24 ++++++++---------
 ...ctionBasedAutoMessagePackSerializerTest.cs | 26 +++++++++----------
 12 files changed, 76 insertions(+), 76 deletions(-)
 rename src/MsgPack/Serialization/{DictionarySerlaizationOptions.cs => DictionarySerializationOptions.cs} (96%)

diff --git a/samples/Samples/Sample03_SerializationContextAndOptions.cs b/samples/Samples/Sample03_SerializationContextAndOptions.cs
index 4ff2f1198..863b054c4 100644
--- a/samples/Samples/Sample03_SerializationContextAndOptions.cs
+++ b/samples/Samples/Sample03_SerializationContextAndOptions.cs
@@ -1,4 +1,4 @@
-#region -- License Terms --
+#region -- License Terms --
 //
 // MessagePack for CLI
 //
@@ -57,9 +57,9 @@ public void CustomizeSerializeBehavior()
 
 			// 2-2-1. You can customize map key handling when you use SerializationMethod.Map to improve interoperability.
 			//        You can use preconfigured transformation in DictionaryKeyTransformers class.
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			// 2-2-2. You can omit entry when map value is null.
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 
 			// 2-3. EnumSerializationMethod: it changes enum serialization as their name or underlying value.
 			//          ByName(default): More version torrelant and interoperable, and backward compatible prior to 0.5 of MsgPack for CLI.
diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs
index 05392bdd4..c58d9e452 100644
--- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs
+++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs
@@ -572,7 +572,7 @@ knownActions[ i ].Value
 							actionCollection.ContextType,
 							"Item",
 							// Set key as transformed.
-							this.MakeStringLiteral( context, context.SerializationContext.DictionarySerlaizationOptions.SafeKeyTransformer( knownActions[ i ].Key ) ),
+							this.MakeStringLiteral( context, context.SerializationContext.DictionarySerializationOptions.SafeKeyTransformer( knownActions[ i ].Key ) ),
 							packItemBody
 						);
 				}
@@ -633,7 +633,7 @@ private IEnumerable<TConstruct> EmitPackNullCheckerTableInitializationCore( TCon
 						actionCollection.ContextType,
 						"Item",
 						// Set key as transformed.
-						this.MakeStringLiteral( context, context.SerializationContext.DictionarySerlaizationOptions.SafeKeyTransformer( knownActions[ i ].Key ) ),
+						this.MakeStringLiteral( context, context.SerializationContext.DictionarySerializationOptions.SafeKeyTransformer( knownActions[ i ].Key ) ),
 						this.EmitNewPrivateMethodDelegateExpression(
 							context,
 							knownActions[ i ].Value
@@ -1351,7 +1351,7 @@ knownActions[ i ].Value
 							actionCollection.ContextType,
 							"Item",
 							// Set key as transformed.
-							this.MakeStringLiteral( context, context.SerializationContext.DictionarySerlaizationOptions.SafeKeyTransformer( knownActions[ i ].Key ) ),
+							this.MakeStringLiteral( context, context.SerializationContext.DictionarySerializationOptions.SafeKeyTransformer( knownActions[ i ].Key ) ),
 							unpackItemBody
 						);
 				}
diff --git a/src/MsgPack/Serialization/DictionaryKeyTransformers.cs b/src/MsgPack/Serialization/DictionaryKeyTransformers.cs
index 7b15970c5..b0f4df332 100644
--- a/src/MsgPack/Serialization/DictionaryKeyTransformers.cs
+++ b/src/MsgPack/Serialization/DictionaryKeyTransformers.cs
@@ -23,7 +23,7 @@
 namespace MsgPack.Serialization
 {
 	/// <summary>
-	///		Defines built-in, out-of-box handlers for <see cref="DictionarySerlaizationOptions.KeyTransformer"/>.
+	///		Defines built-in, out-of-box handlers for <see cref="DictionarySerializationOptions.KeyTransformer"/>.
 	/// </summary>
 	public static class DictionaryKeyTransformers
 	{
diff --git a/src/MsgPack/Serialization/DictionarySerlaizationOptions.cs b/src/MsgPack/Serialization/DictionarySerializationOptions.cs
similarity index 96%
rename from src/MsgPack/Serialization/DictionarySerlaizationOptions.cs
rename to src/MsgPack/Serialization/DictionarySerializationOptions.cs
index eff1977d5..0f5f86c18 100644
--- a/src/MsgPack/Serialization/DictionarySerlaizationOptions.cs
+++ b/src/MsgPack/Serialization/DictionarySerializationOptions.cs
@@ -35,7 +35,7 @@ namespace MsgPack.Serialization
 	///		and <see cref="System.Collections.Generic.IDictionary{TKey, TValue}"/>.
 	///		The option only affect dictionary (map) based serialization which can be enabled via <see cref="SerializationContext.SerializationMethod"/>.
 	/// </remarks>
-	public sealed class DictionarySerlaizationOptions
+	public sealed class DictionarySerializationOptions
 	{
 #if !FEATURE_CONCURRENT
 		private volatile bool _omitNullEntry;
@@ -121,8 +121,8 @@ internal Func<string, string> SafeKeyTransformer
 		} 
 
 		/// <summary>
-		///		Initializes a new instance of the <see cref="DictionarySerlaizationOptions"/> class.
+		///		Initializes a new instance of the <see cref="DictionarySerializationOptions"/> class.
 		/// </summary>
-		public DictionarySerlaizationOptions() { }
+		public DictionarySerializationOptions() { }
 	}
 }
diff --git a/src/MsgPack/Serialization/MessagePackSerializer`1.cs b/src/MsgPack/Serialization/MessagePackSerializer`1.cs
index 8434bc622..3f19466d1 100644
--- a/src/MsgPack/Serialization/MessagePackSerializer`1.cs
+++ b/src/MsgPack/Serialization/MessagePackSerializer`1.cs
@@ -1,4 +1,4 @@
-#region -- License Terms --
+#region -- License Terms --
 //
 // MessagePack for CLI
 //
@@ -61,7 +61,7 @@ public abstract class MessagePackSerializer<T> : MessagePackSerializer
 		/// <remarks>
 		///		This method supports backword compatibility with 0.3.
 		/// </remarks>
-		[Obsolete( "Use MessagePackSerializer (SerlaizationContext) instead." )]
+		[Obsolete( "Use MessagePackSerializer (SerializationContext) instead." )]
 		protected MessagePackSerializer() : this( PackerCompatibilityOptions.Classic ) { }
 
 		/// <summary>
@@ -71,7 +71,7 @@ protected MessagePackSerializer() : this( PackerCompatibilityOptions.Classic ) {
 		/// <remarks>
 		///		This method supports backword compatibility with 0.4.
 		/// </remarks>
-		[Obsolete( "Use MessagePackSerializer (SerlaizationContext, PackerCompatibilityOptions) instead." )]
+		[Obsolete( "Use MessagePackSerializer (SerializationContext, PackerCompatibilityOptions) instead." )]
 		protected MessagePackSerializer( PackerCompatibilityOptions packerCompatibilityOptions )
 			: this( null, packerCompatibilityOptions ) { }
 
diff --git a/src/MsgPack/Serialization/PackHelpers.cs b/src/MsgPack/Serialization/PackHelpers.cs
index 31d3da745..616aa4ab8 100644
--- a/src/MsgPack/Serialization/PackHelpers.cs
+++ b/src/MsgPack/Serialization/PackHelpers.cs
@@ -339,7 +339,7 @@ ref PackToMapParameters<TObject> parameter
 #endif // ASSERT
 
 			if ( parameter.NullCheckers != null 
-				&& parameter.SerializationContext != null && parameter.SerializationContext.DictionarySerlaizationOptions.OmitNullEntry )
+				&& parameter.SerializationContext != null && parameter.SerializationContext.DictionarySerializationOptions.OmitNullEntry )
 			{
 #if ASSERT
 				Contract.Assert( !SerializerDebugging.UseLegacyNullMapEntryHandling );
@@ -487,7 +487,7 @@ CancellationToken cancellationToken
 #endif // ASSERT
 
 			if ( nullCheckers != null
-				&& serializationContext != null && serializationContext.DictionarySerlaizationOptions.OmitNullEntry )
+				&& serializationContext != null && serializationContext.DictionarySerializationOptions.OmitNullEntry )
 			{
 #if ASSERT
 				Contract.Assert( !SerializerDebugging.UseLegacyNullMapEntryHandling );
diff --git a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs
index bb9656c32..bb060346c 100644
--- a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs
+++ b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs
@@ -66,7 +66,7 @@ public ReflectionObjectMessagePackSerializer( SerializationContext context, Seri
 					.Select( ( contract, index ) => new KeyValuePair<string, int>( contract.Name, index ) )
 					.Where( kv => kv.Key != null )
 					// Set key as transformed.
-					.ToDictionary( kv => context.DictionarySerlaizationOptions.SafeKeyTransformer( kv.Key ), kv => kv.Value );
+					.ToDictionary( kv => context.DictionarySerializationOptions.SafeKeyTransformer( kv.Key ), kv => kv.Value );
 			this._constructorParameters =
 				( !typeof( IUnpackable ).IsAssignableFrom( typeof( T ) ) && target.IsConstructorDeserialization )
 					? target.DeserializationConstructor.GetParameters()
@@ -112,7 +112,7 @@ protected internal override void PackToCore( Packer packer, T objectTree )
 			}
 			else
 			{
-				if ( this.OwnerContext.DictionarySerlaizationOptions.OmitNullEntry
+				if ( this.OwnerContext.DictionarySerializationOptions.OmitNullEntry
 #if DEBUG
 					&& !SerializerDebugging.UseLegacyNullMapEntryHandling
 #endif // DEBUG
@@ -138,7 +138,7 @@ protected internal override void PackToCore( Packer packer, T objectTree )
 						}
 
 						// Set key as transformed.
-						packer.PackString( this.OwnerContext.DictionarySerlaizationOptions.SafeKeyTransformer( this._contracts[ i ].Name ) );
+						packer.PackString( this.OwnerContext.DictionarySerializationOptions.SafeKeyTransformer( this._contracts[ i ].Name ) );
 						this.PackMemberValue( packer, objectTree, i );
 					}
 				}
@@ -148,7 +148,7 @@ protected internal override void PackToCore( Packer packer, T objectTree )
 					for ( int i = 0; i < this._serializers.Length; i++ )
 					{
 						// Set key as transformed.
-						packer.PackString( this.OwnerContext.DictionarySerlaizationOptions.SafeKeyTransformer( this._contracts[ i ].Name ) );
+						packer.PackString( this.OwnerContext.DictionarySerializationOptions.SafeKeyTransformer( this._contracts[ i ].Name ) );
 						this.PackMemberValue( packer, objectTree, i );
 					}
 				}
@@ -214,7 +214,7 @@ protected internal override async Task PackToAsyncCore( Packer packer, T objectT
 			}
 			else
 			{
-				if ( this.OwnerContext.DictionarySerlaizationOptions.OmitNullEntry
+				if ( this.OwnerContext.DictionarySerializationOptions.OmitNullEntry
 #if DEBUG
 					&& !SerializerDebugging.UseLegacyNullMapEntryHandling
 #endif // DEBUG
@@ -240,7 +240,7 @@ protected internal override async Task PackToAsyncCore( Packer packer, T objectT
 						}
 
 						// Set key as transformed.
-						await packer.PackStringAsync( this.OwnerContext.DictionarySerlaizationOptions.SafeKeyTransformer( this._contracts[ i ].Name ), cancellationToken ).ConfigureAwait( false );
+						await packer.PackStringAsync( this.OwnerContext.DictionarySerializationOptions.SafeKeyTransformer( this._contracts[ i ].Name ), cancellationToken ).ConfigureAwait( false );
 						await this.PackMemberValueAsync( packer, objectTree, i, cancellationToken ).ConfigureAwait( false );
 					}
 				}
@@ -250,7 +250,7 @@ protected internal override async Task PackToAsyncCore( Packer packer, T objectT
 					for ( int i = 0; i < this._serializers.Length; i++ )
 					{
 						// Set key as transformed.
-						await packer.PackStringAsync( this.OwnerContext.DictionarySerlaizationOptions.SafeKeyTransformer( this._contracts[ i ].Name ), cancellationToken ).ConfigureAwait( false );
+						await packer.PackStringAsync( this.OwnerContext.DictionarySerializationOptions.SafeKeyTransformer( this._contracts[ i ].Name ), cancellationToken ).ConfigureAwait( false );
 						await this.PackMemberValueAsync( packer, objectTree, i, cancellationToken ).ConfigureAwait( false );
 					}
 				}
diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index 1a91f72dd..1cdc1a564 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -196,20 +196,20 @@ public SerializationCompatibilityOptions CompatibilityOptions
 			}
 		}
 
-		private readonly DictionarySerlaizationOptions _dictionarySerializationOptions;
+		private readonly DictionarySerializationOptions _dictionarySerializationOptions;
 
 		/// <summary>
 		///		Gets the dictionary(map) based serialization options.
 		/// </summary>
 		/// <value>
-		///		The <see cref="DictionarySerlaizationOptions"/> which stores dictionary(map) based serialization options. This value will not be <c>null</c>.
+		///		The <see cref="DictionarySerializationOptions"/> which stores dictionary(map) based serialization options. This value will not be <c>null</c>.
 		/// </value>
-		public DictionarySerlaizationOptions DictionarySerlaizationOptions
+		public DictionarySerializationOptions DictionarySerializationOptions
 		{
 			get
 			{
 #if DEBUG
-				Contract.Ensures( Contract.Result<DictionarySerlaizationOptions>() != null );
+				Contract.Ensures( Contract.Result<DictionarySerializationOptions>() != null );
 #endif // DEBUG
 
 				return this._dictionarySerializationOptions;
@@ -561,7 +561,7 @@ public SerializationContext( PackerCompatibilityOptions packerCompatibilityOptio
 			this._generationLock = new object();
 			this._defaultCollectionTypes = new DefaultConcreteTypeRepository();
 			this._serializerGeneratorOptions = new SerializerOptions();
-			this._dictionarySerializationOptions = new DictionarySerlaizationOptions();
+			this._dictionarySerializationOptions = new DictionarySerializationOptions();
 			this._enumSerializationOptions = new EnumSerializationOptions();
 			this._bindingOptions = new BindingOptions();
 		}
diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs
index f7e10d905..4d83db4bd 100644
--- a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs
@@ -9076,9 +9076,9 @@ public void TestImplementsNonGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCo
 		public void TestOmitNullEntryInDictionary()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, false );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, false );
 		}
 
@@ -9088,9 +9088,9 @@ public void TestOmitNullEntryInDictionary()
 		public void TestOmitNullEntryInDictionary_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, true );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, true );
 		}
 
@@ -9103,7 +9103,7 @@ public void TestOmitNullEntryInDictionary_BackwordCompatibility()
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, false );
 			}
 			finally
@@ -9121,7 +9121,7 @@ public void TestOmitNullEntryInDictionary_BackwordCompatibility_Async()
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, true );
 			}
 			finally
@@ -9195,7 +9195,7 @@ private static void TestOmitNullEntryInDictionaryCore( SerializationContext cont
 		public void TestDictionaryKeyTransformer_Default_AsIs()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: false );
 		}
 
@@ -9205,7 +9205,7 @@ public void TestDictionaryKeyTransformer_Default_AsIs()
 		public void TestDictionaryKeyTransformer_Default_AsIs_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: true );
 		}
 
@@ -9215,7 +9215,7 @@ public void TestDictionaryKeyTransformer_Default_AsIs_Async()
 		public void TestDictionaryKeyTransformer_LowerCamel()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: false );
 		}
 
@@ -9225,7 +9225,7 @@ public void TestDictionaryKeyTransformer_LowerCamel()
 		public void TestDictionaryKeyTransformer_LowerCamel_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: true );
 		}
 
@@ -9235,7 +9235,7 @@ public void TestDictionaryKeyTransformer_LowerCamel_Async()
 		public void TestDictionaryKeyTransformer_Custom()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: false );
 		}
@@ -9246,7 +9246,7 @@ public void TestDictionaryKeyTransformer_Custom()
 		public void TestDictionaryKeyTransformer_Custom_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: true );
 		}
diff --git a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude
index 6f1d80413..4aa728d34 100644
--- a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude
+++ b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude
@@ -3798,9 +3798,9 @@ namespace MsgPack.Serialization
 		public void TestOmitNullEntryInDictionary()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, false );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, false );
 		}
 
@@ -3810,9 +3810,9 @@ namespace MsgPack.Serialization
 		public void TestOmitNullEntryInDictionary_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, true );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, true );
 		}
 
@@ -3825,7 +3825,7 @@ namespace MsgPack.Serialization
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, false );
 			}
 			finally
@@ -3843,7 +3843,7 @@ namespace MsgPack.Serialization
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, true );
 			}
 			finally
@@ -3917,7 +3917,7 @@ namespace MsgPack.Serialization
 		public void TestDictionaryKeyTransformer_Default_AsIs()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: false );
 		}
 
@@ -3927,7 +3927,7 @@ namespace MsgPack.Serialization
 		public void TestDictionaryKeyTransformer_Default_AsIs_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: true );
 		}
 
@@ -3937,7 +3937,7 @@ namespace MsgPack.Serialization
 		public void TestDictionaryKeyTransformer_LowerCamel()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: false );
 		}
 
@@ -3947,7 +3947,7 @@ namespace MsgPack.Serialization
 		public void TestDictionaryKeyTransformer_LowerCamel_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: true );
 		}
 
@@ -3957,7 +3957,7 @@ namespace MsgPack.Serialization
 		public void TestDictionaryKeyTransformer_Custom()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: false );
 		}
@@ -3968,7 +3968,7 @@ namespace MsgPack.Serialization
 		public void TestDictionaryKeyTransformer_Custom_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: true );
 		}
diff --git a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs
index 80af2f0c9..7d73e4d9d 100644
--- a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs
@@ -9076,9 +9076,9 @@ public void TestImplementsNonGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCo
 		public void TestOmitNullEntryInDictionary()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, false );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, false );
 		}
 
@@ -9088,9 +9088,9 @@ public void TestOmitNullEntryInDictionary()
 		public void TestOmitNullEntryInDictionary_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, true );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, true );
 		}
 
@@ -9103,7 +9103,7 @@ public void TestOmitNullEntryInDictionary_BackwordCompatibility()
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, false );
 			}
 			finally
@@ -9121,7 +9121,7 @@ public void TestOmitNullEntryInDictionary_BackwordCompatibility_Async()
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, true );
 			}
 			finally
@@ -9195,7 +9195,7 @@ private static void TestOmitNullEntryInDictionaryCore( SerializationContext cont
 		public void TestDictionaryKeyTransformer_Default_AsIs()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: false );
 		}
 
@@ -9205,7 +9205,7 @@ public void TestDictionaryKeyTransformer_Default_AsIs()
 		public void TestDictionaryKeyTransformer_Default_AsIs_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: true );
 		}
 
@@ -9215,7 +9215,7 @@ public void TestDictionaryKeyTransformer_Default_AsIs_Async()
 		public void TestDictionaryKeyTransformer_LowerCamel()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: false );
 		}
 
@@ -9225,7 +9225,7 @@ public void TestDictionaryKeyTransformer_LowerCamel()
 		public void TestDictionaryKeyTransformer_LowerCamel_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: true );
 		}
 
@@ -9235,7 +9235,7 @@ public void TestDictionaryKeyTransformer_LowerCamel_Async()
 		public void TestDictionaryKeyTransformer_Custom()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: false );
 		}
@@ -9246,7 +9246,7 @@ public void TestDictionaryKeyTransformer_Custom()
 		public void TestDictionaryKeyTransformer_Custom_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: true );
 		}
diff --git a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs
index 2fbeb31fb..c7fbaec1f 100644
--- a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs
+++ b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs
@@ -1,4 +1,4 @@
-
+
 
 
 #region -- License Terms --
@@ -8977,9 +8977,9 @@ public void TestImplementsNonGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCo
 		public void TestOmitNullEntryInDictionary()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, false );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, false );
 		}
 
@@ -8989,9 +8989,9 @@ public void TestOmitNullEntryInDictionary()
 		public void TestOmitNullEntryInDictionary_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" );
+			Assert.That( context.DictionarySerializationOptions.OmitNullEntry, Is.False, "default value" );
 			TestOmitNullEntryInDictionaryCore( context, true, true );
-			context.DictionarySerlaizationOptions.OmitNullEntry = true;
+			context.DictionarySerializationOptions.OmitNullEntry = true;
 			TestOmitNullEntryInDictionaryCore( context, false, true );
 		}
 
@@ -9004,7 +9004,7 @@ public void TestOmitNullEntryInDictionary_BackwordCompatibility()
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, false );
 			}
 			finally
@@ -9022,7 +9022,7 @@ public void TestOmitNullEntryInDictionary_BackwordCompatibility_Async()
 			try
 			{
 				var context = GetSerializationContext();
-				context.DictionarySerlaizationOptions.OmitNullEntry = true;
+				context.DictionarySerializationOptions.OmitNullEntry = true;
 				TestOmitNullEntryInDictionaryCore( context, true, true );
 			}
 			finally
@@ -9096,7 +9096,7 @@ private static void TestOmitNullEntryInDictionaryCore( SerializationContext cont
 		public void TestDictionaryKeyTransformer_Default_AsIs()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: false );
 		}
 
@@ -9106,7 +9106,7 @@ public void TestDictionaryKeyTransformer_Default_AsIs()
 		public void TestDictionaryKeyTransformer_Default_AsIs_Async()
 		{
 			var context = GetSerializationContext();
-			Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" );
+			Assert.That( context.DictionarySerializationOptions.KeyTransformer, Is.Null, "default value" );
 			TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: true );
 		}
 
@@ -9116,7 +9116,7 @@ public void TestDictionaryKeyTransformer_Default_AsIs_Async()
 		public void TestDictionaryKeyTransformer_LowerCamel()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: false );
 		}
 
@@ -9126,7 +9126,7 @@ public void TestDictionaryKeyTransformer_LowerCamel()
 		public void TestDictionaryKeyTransformer_LowerCamel_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
+			context.DictionarySerializationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel;
 			TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: true );
 		}
 
@@ -9136,7 +9136,7 @@ public void TestDictionaryKeyTransformer_LowerCamel_Async()
 		public void TestDictionaryKeyTransformer_Custom()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: false );
 		}
@@ -9147,7 +9147,7 @@ public void TestDictionaryKeyTransformer_Custom()
 		public void TestDictionaryKeyTransformer_Custom_Async()
 		{
 			var context = GetSerializationContext();
-			context.DictionarySerlaizationOptions.KeyTransformer = 
+			context.DictionarySerializationOptions.KeyTransformer = 
 				key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() );
 			TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: true );
 		}

From 0e710141eb46badf1ef1a9f93431d3d88d94c402 Mon Sep 17 00:00:00 2001
From: Lucas Pimentel <lucas.pimentel@datadoghq.com>
Date: Thu, 1 Nov 2018 12:24:43 -0400
Subject: [PATCH 14/36] Add .NETStandard2.0 dependencies to NuGet packages

---
 MsgPack.nuspec | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/MsgPack.nuspec b/MsgPack.nuspec
index 3a4062a4f..aa088e4d2 100644
--- a/MsgPack.nuspec
+++ b/MsgPack.nuspec
@@ -76,6 +76,12 @@ This package provides MessagePack serialization/deserialization APIs. This pacak
         <dependency id="System.Text.RegularExpressions" version="4.1.0" />
         <dependency id="System.Threading" version="4.0.11" />
       </group>
+      <group targetFramework=".NETStandard2.0">
+        <dependency id="System.CodeDom" version="4.4.0" exclude="Build,Analyzers" />
+        <dependency id="System.Numerics.Vectors" version="4.3.0" exclude="Build,Analyzers" />
+        <dependency id="System.Reflection.Emit" version="4.3.0" exclude="Build,Analyzers" />
+        <dependency id="System.Reflection.Emit.LightWeight" version="4.3.0" exclude="Build,Analyzers" />
+      </group>
       <group targetFramework="uap10.0">
         <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="5.2.2" />
         <dependency id="System.Collections.NonGeneric" version="4.0.1" />
@@ -89,4 +95,4 @@ This package provides MessagePack serialization/deserialization APIs. This pacak
     <file src="bin\**\*.pdb" target="lib" exclude="**\System.*;**\Microsoft.*;**\Mono.*" />
     <file src="src\**\*.cs" target="src" />
   </files>
-</package>
\ No newline at end of file
+</package>

From 0c609b2c6941e446364ae2d20a4be59b295563ee Mon Sep 17 00:00:00 2001
From: shimat <schimatk@gmail.com>
Date: Fri, 9 Nov 2018 17:59:49 +0900
Subject: [PATCH 15/36] remain old name DictionarySerlaizationOptions

---
 .../Serialization/SerializationContext.cs     | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index 1cdc1a564..44e2a375e 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -23,6 +23,7 @@
 #endif
 
 using System;
+using System.ComponentModel;
 #if !UNITY || MSGPACK_UNITY_FULL
 #endif // !UNITY || MSGPACK_UNITY_FULL
 #if FEATURE_CONCURRENT
@@ -216,6 +217,28 @@ public DictionarySerializationOptions DictionarySerializationOptions
 			}
 		}
 
+		/// <summary>
+		///		Gets the dictionary(map) based serialization options.
+		/// </summary>
+		/// <value>
+		///		The <see cref="DictionarySerializationOptions"/> which stores dictionary(map) based serialization options. This value will not be <c>null</c>.
+		/// </value>
+		[Obsolete("Use DictionarySerializationOption instead.")]
+#if XAMARIN && ( __ANDROID__ || __IOS__ )
+		[EditorBrowsable(EditorBrowsableState.Never)]
+#endif
+		public DictionarySerializationOptions DictionarySerlaizationOptions
+		{
+			get
+			{
+#if DEBUG
+				Contract.Ensures( Contract.Result<DictionarySerializationOptions>() != null );
+#endif // DEBUG
+
+				return this._dictionarySerializationOptions;
+			}
+		}
+
 		private int _serializationMethod;
 
 		/// <summary>

From 829661e67be807db926be39f702ce6f653d867f1 Mon Sep 17 00:00:00 2001
From: shimat <schimatk@gmail.com>
Date: Wed, 14 Nov 2018 10:12:09 +0900
Subject: [PATCH 16/36] Run SyncProject.bat to synchronize added/removed files

---
 src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj | 10 +++++-----
 .../MsgPack.Silverlight.WindowsPhone.csproj            | 10 +++++-----
 src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj       | 10 +++++-----
 src/MsgPack.Unity/MsgPack.Unity.csproj                 | 10 +++++-----
 src/MsgPack.Uwp/MsgPack.Uwp.csproj                     | 10 +++++-----
 .../MsgPack.UnitTest.Silverlight.5.FullTrust.csproj    |  3 +++
 .../MsgPack.UnitTest.Silverlight.5.csproj              |  3 +++
 .../MsgPack.UnitTest.Silverlight.WindowsPhone.csproj   |  3 +++
 .../MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj  |  3 +++
 .../MsgPack.UnitTest.Uwp.Aot.csproj                    |  3 +++
 test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj  |  3 +++
 .../MsgPack.UnitTest.WinRT.WindowsPhone.csproj         |  6 ++++--
 .../MsgPack.UnitTest.WinRT.csproj                      |  3 +++
 .../MsgPack.UnitTest.Xamarin.Android.csproj            |  6 ++++--
 .../MsgPack.UnitTest.Xamarin.iOS.csproj                |  3 +++
 15 files changed, 57 insertions(+), 29 deletions(-)

diff --git a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
index 45b5284a5..eee754480 100644
--- a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
+++ b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj
@@ -245,6 +245,9 @@
     <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.ConstructorDelegate.cs">
       <Link>Serialization\ReflectionExtensions.ConstructorDelegate.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -455,8 +458,8 @@
     <Compile Include="..\MsgPack\Serialization\DictionaryKeyTransformers.cs">
       <Link>Serialization\DictionaryKeyTransformers.cs</Link>
     </Compile>
-    <Compile Include="..\MsgPack\Serialization\DictionarySerlaizationOptions.cs">
-      <Link>Serialization\DictionarySerlaizationOptions.cs</Link>
+    <Compile Include="..\MsgPack\Serialization\DictionarySerializationOptions.cs">
+      <Link>Serialization\DictionarySerializationOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\EmitterFlavor.cs">
       <Link>Serialization\EmitterFlavor.cs</Link>
@@ -673,9 +676,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
index 399b5796f..da130b1c6 100644
--- a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
+++ b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj
@@ -216,6 +216,9 @@
     <Compile Include="..\MsgPack\ReflectionAbstractions.cs">
       <Link>ReflectionAbstractions.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -462,8 +465,8 @@
     <Compile Include="..\MsgPack\Serialization\DictionaryKeyTransformers.cs">
       <Link>Serialization\DictionaryKeyTransformers.cs</Link>
     </Compile>
-    <Compile Include="..\MsgPack\Serialization\DictionarySerlaizationOptions.cs">
-      <Link>Serialization\DictionarySerlaizationOptions.cs</Link>
+    <Compile Include="..\MsgPack\Serialization\DictionarySerializationOptions.cs">
+      <Link>Serialization\DictionarySerializationOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\EmitterFlavor.cs">
       <Link>Serialization\EmitterFlavor.cs</Link>
@@ -680,9 +683,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
index 00a022cb8..67c693925 100644
--- a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
+++ b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj
@@ -220,6 +220,9 @@
     <Compile Include="..\MsgPack\Serialization\Tracer.cs">
       <Link>Serialization\Tracer.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -436,8 +439,8 @@
     <Compile Include="..\MsgPack\Serialization\DictionaryKeyTransformers.cs">
       <Link>Serialization\DictionaryKeyTransformers.cs</Link>
     </Compile>
-    <Compile Include="..\MsgPack\Serialization\DictionarySerlaizationOptions.cs">
-      <Link>Serialization\DictionarySerlaizationOptions.cs</Link>
+    <Compile Include="..\MsgPack\Serialization\DictionarySerializationOptions.cs">
+      <Link>Serialization\DictionarySerializationOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\EmitterFlavor.cs">
       <Link>Serialization\EmitterFlavor.cs</Link>
@@ -651,9 +654,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/src/MsgPack.Unity/MsgPack.Unity.csproj b/src/MsgPack.Unity/MsgPack.Unity.csproj
index 53ca4e7a3..40927b6fa 100644
--- a/src/MsgPack.Unity/MsgPack.Unity.csproj
+++ b/src/MsgPack.Unity/MsgPack.Unity.csproj
@@ -234,13 +234,13 @@
     </Compile>
     <Compile Include="..\MsgPack\ReflectionAbstractions.cs">
       <Link>ReflectionAbstractions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\Tracer.cs">
       <Link>Serialization\Tracer.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -445,8 +445,8 @@
     <Compile Include="..\MsgPack\Serialization\DictionaryKeyTransformers.cs">
       <Link>Serialization\DictionaryKeyTransformers.cs</Link>
     </Compile>
-    <Compile Include="..\MsgPack\Serialization\DictionarySerlaizationOptions.cs">
-      <Link>Serialization\DictionarySerlaizationOptions.cs</Link>
+    <Compile Include="..\MsgPack\Serialization\DictionarySerializationOptions.cs">
+      <Link>Serialization\DictionarySerializationOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\EmitterFlavor.cs">
       <Link>Serialization\EmitterFlavor.cs</Link>
diff --git a/src/MsgPack.Uwp/MsgPack.Uwp.csproj b/src/MsgPack.Uwp/MsgPack.Uwp.csproj
index f32d07373..473792780 100644
--- a/src/MsgPack.Uwp/MsgPack.Uwp.csproj
+++ b/src/MsgPack.Uwp/MsgPack.Uwp.csproj
@@ -244,6 +244,9 @@
     <Compile Include="..\MsgPack\ReflectionAbstractions.cs">
       <Link>ReflectionAbstractions.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
+      <Link>Serialization\BindingOptions.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs">
       <Link>Serialization\CollectionDetailedKind.cs</Link>
     </Compile>
@@ -505,8 +508,8 @@
     <Compile Include="..\MsgPack\Serialization\DictionaryKeyTransformers.cs">
       <Link>Serialization\DictionaryKeyTransformers.cs</Link>
     </Compile>
-    <Compile Include="..\MsgPack\Serialization\DictionarySerlaizationOptions.cs">
-      <Link>Serialization\DictionarySerlaizationOptions.cs</Link>
+    <Compile Include="..\MsgPack\Serialization\DictionarySerializationOptions.cs">
+      <Link>Serialization\DictionarySerializationOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\EmitterFlavor.cs">
       <Link>Serialization\EmitterFlavor.cs</Link>
@@ -723,9 +726,6 @@
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationCompatibilityOptions.cs">
       <Link>Serialization\SerializationCompatibilityOptions.cs</Link>
-    </Compile>	
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs">
-      <Link>Serialization\BindingOptions.cs</Link>
     </Compile>
     <Compile Include="..\MsgPack\Serialization\SerializationContext.cs">
       <Link>Serialization\SerializationContext.cs</Link>
diff --git a/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj b/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj
index ae00ef81f..d1b79c9db 100644
--- a/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj
+++ b/test/MsgPack.UnitTest.Silverlight.5.FullTrust/MsgPack.UnitTest.Silverlight.5.FullTrust.csproj
@@ -136,6 +136,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj b/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj
index 4ec3ed4d8..68a03a547 100644
--- a/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj
+++ b/test/MsgPack.UnitTest.Silverlight.5/MsgPack.UnitTest.Silverlight.5.csproj
@@ -121,6 +121,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj b/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj
index b799f51f8..a9c359ebe 100644
--- a/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj
+++ b/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj
@@ -99,6 +99,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj b/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj
index c32f912e9..253381245 100644
--- a/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj
+++ b/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj
@@ -442,6 +442,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
index ac6872671..bed3a2487 100644
--- a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
+++ b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj
@@ -1551,6 +1551,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
index 081f56673..d3ec2abe9 100644
--- a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
+++ b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj
@@ -1533,6 +1533,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj b/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj
index 3aca36e1c..07981094b 100644
--- a/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj
+++ b/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj
@@ -22,8 +22,7 @@
   </PropertyGroup>
   <Import Project="..\..\MsgPack.Common.props" />
   <PropertyGroup>
-    <DocumentationFile>
-    </DocumentationFile>
+    <DocumentationFile></DocumentationFile>
     <DefineConstants>$(DefineConstants);NETFX_CORE;WINDOWS_PHONE_APP;NETSTANDARD1_1;FEATURE_TAP;MSTEST</DefineConstants>
     <NoWarn>;2008</NoWarn>
   </PropertyGroup>
@@ -122,6 +121,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
index e0e54b445..84ed4aab3 100644
--- a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
+++ b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj
@@ -127,6 +127,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
diff --git a/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj b/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj
index 286251f05..a7e8ea4cd 100644
--- a/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj
+++ b/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj
@@ -58,6 +58,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>
@@ -259,11 +262,10 @@
     <Compile Include="..\MsgPack.UnitTest\TestRandom.cs">
       <Link>TestRandom.cs</Link>
     </Compile>
-    <Compile Include="Resources\Resource.designer.cs" />
   </ItemGroup>
   <ItemGroup>
     <AndroidResource Include="Resources\drawable\Icon.png" />
-    <AndroidResource Include="Resources\values\Strings.xml" >
+    <AndroidResource Include="Resources\values\Strings.xml">
       <SubType>Designer</SubType>
     </AndroidResource>
   </ItemGroup>
diff --git a/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj b/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj
index 5fb06be4c..3619a69a6 100644
--- a/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj
+++ b/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj
@@ -58,6 +58,9 @@
     <Compile Include="..\MsgPack.UnitTest\MessagePackExtendedTypeObjectTest.cs">
       <Link>MessagePackExtendedTypeObjectTest.cs</Link>
     </Compile>
+    <Compile Include="..\MsgPack.UnitTest\MessagePackMemberSkipTest.cs">
+      <Link>MessagePackMemberSkipTest.cs</Link>
+    </Compile>
     <Compile Include="..\MsgPack.UnitTest\MessagePackObjectDictionaryTest.cs">
       <Link>MessagePackObjectDictionaryTest.cs</Link>
     </Compile>

From 1f0bba94545f1d4e915df3e9fea538d5a100ee05 Mon Sep 17 00:00:00 2001
From: shimat <schimatk@gmail.com>
Date: Wed, 14 Nov 2018 10:55:43 +0900
Subject: [PATCH 17/36] fixed #if directive of DictionarySerializationOptions

---
 src/MsgPack/Serialization/SerializationContext.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index 44e2a375e..c02b375aa 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -23,7 +23,6 @@
 #endif
 
 using System;
-using System.ComponentModel;
 #if !UNITY || MSGPACK_UNITY_FULL
 #endif // !UNITY || MSGPACK_UNITY_FULL
 #if FEATURE_CONCURRENT
@@ -224,8 +223,8 @@ public DictionarySerializationOptions DictionarySerializationOptions
 		///		The <see cref="DictionarySerializationOptions"/> which stores dictionary(map) based serialization options. This value will not be <c>null</c>.
 		/// </value>
 		[Obsolete("Use DictionarySerializationOption instead.")]
-#if XAMARIN && ( __ANDROID__ || __IOS__ )
-		[EditorBrowsable(EditorBrowsableState.Never)]
+#if !UNITY && !( XAMARIN && ( __ANDROID__ || __IOS__ ) )
+		[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
 #endif
 		public DictionarySerializationOptions DictionarySerlaizationOptions
 		{

From 93bfff8b58553ed6255e5d550c9edfcb99dc9369 Mon Sep 17 00:00:00 2001
From: shimat <schimatk@gmail.com>
Date: Mon, 19 Nov 2018 10:19:44 +0900
Subject: [PATCH 18/36] use #if MSGPACK_UNITY_FULL

---
 src/MsgPack/Serialization/SerializationContext.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index c02b375aa..db2b2f48e 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -24,6 +24,7 @@
 
 using System;
 #if !UNITY || MSGPACK_UNITY_FULL
+using System.ComponentModel;
 #endif // !UNITY || MSGPACK_UNITY_FULL
 #if FEATURE_CONCURRENT
 using System.Collections.Concurrent;
@@ -223,8 +224,8 @@ public DictionarySerializationOptions DictionarySerializationOptions
 		///		The <see cref="DictionarySerializationOptions"/> which stores dictionary(map) based serialization options. This value will not be <c>null</c>.
 		/// </value>
 		[Obsolete("Use DictionarySerializationOption instead.")]
-#if !UNITY && !( XAMARIN && ( __ANDROID__ || __IOS__ ) )
-		[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+#if !UNITY || MSGPACK_UNITY_FULL
+		[EditorBrowsable(EditorBrowsableState.Never)]
 #endif
 		public DictionarySerializationOptions DictionarySerlaizationOptions
 		{

From 4ca7dd6d87a77a629e93f235afac77ac996773b2 Mon Sep 17 00:00:00 2001
From: Teddy LE BRAS <teddy.lebras@gmail.com>
Date: Wed, 5 Jun 2019 16:21:12 +0200
Subject: [PATCH 19/36] Fix typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bbf89204a..f84d6b047 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,7 @@ serializer.Pack(stream, obj)
 Dim unpackedObject = serializer.Unpack(stream)
 ```
 
-**For production environment, you should instantiate own `SerializationCOntext` and manage its lifetime. It is good idea to treat it as singleton because `SerializationContext` is thread-safe.**
+**For production environment, you should instantiate own `SerializationContext` and manage its lifetime. It is good idea to treat it as singleton because `SerializationContext` is thread-safe.**
 
 ## Features
 

From a983c2399afc6ed8225b7dc4afe8316acb6eea43 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 27 May 2019 20:40:24 +0900
Subject: [PATCH 20/36] Fix default buffering strategy for stream
 deserialization to prevent discarding unpacking data. #321

For detailed information, see #321 comment.
---
 src/MsgPack/PackerUnpackerStreamOptions.cs    | 12 ++++++++-
 .../Serialization/MessagePackSerializer`1.cs  |  4 +--
 .../Serialization/RegressionTests.cs          | 26 +++++++++++++++++++
 3 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/src/MsgPack/PackerUnpackerStreamOptions.cs b/src/MsgPack/PackerUnpackerStreamOptions.cs
index 71a1bf8f5..9500851db 100644
--- a/src/MsgPack/PackerUnpackerStreamOptions.cs
+++ b/src/MsgPack/PackerUnpackerStreamOptions.cs
@@ -82,9 +82,19 @@ private static bool ShouldWrapStream( Stream stream )
 #else
 		internal
 #endif
-		static readonly PackerUnpackerStreamOptions SingletonForAsync =
+		static readonly PackerUnpackerStreamOptions SingletonForAsyncPacking =
+			// It is OK for serialize to do buffering because we explicitly call FlushAsync for it.
 			new PackerUnpackerStreamOptions { OwnsStream = true, WithBuffering = true };
 
+		#if UNITY && DEBUG
+		public
+#else
+		internal
+#endif
+		static readonly PackerUnpackerStreamOptions SingletonForAsyncUnpacking =
+			// Buffering causes data loss in deserialization because buffered bytes will be gone in a tail of Deserialize(Stream) call.
+			new PackerUnpackerStreamOptions { OwnsStream = true, WithBuffering = false };
+
 #if UNITY && DEBUG
 		public
 #else
diff --git a/src/MsgPack/Serialization/MessagePackSerializer`1.cs b/src/MsgPack/Serialization/MessagePackSerializer`1.cs
index 3f19466d1..3bebc04a7 100644
--- a/src/MsgPack/Serialization/MessagePackSerializer`1.cs
+++ b/src/MsgPack/Serialization/MessagePackSerializer`1.cs
@@ -219,7 +219,7 @@ public Task PackAsync( Stream stream, T objectTree )
 		/// <seealso cref="P:Capabilities"/>
 		public async Task PackAsync( Stream stream, T objectTree, CancellationToken cancellationToken )
 		{
-			var packer = Packer.Create( stream, this.PackerCompatibilityOptions, PackerUnpackerStreamOptions.SingletonForAsync );
+			var packer = Packer.Create( stream, this.PackerCompatibilityOptions, PackerUnpackerStreamOptions.SingletonForAsyncPacking );
 			try
 			{
 				await this.PackToAsync( packer, objectTree, cancellationToken ).ConfigureAwait( false );
@@ -324,7 +324,7 @@ public Task<T> UnpackAsync( Stream stream )
 		public async Task<T> UnpackAsync( Stream stream, CancellationToken cancellationToken )
 		{
 			// Unpacker does not have finalizer, so just avoiding unpacker disposing prevents stream closing.
-			var unpacker = Unpacker.Create( stream, PackerUnpackerStreamOptions.SingletonForAsync, DefaultUnpackerOptions );
+			var unpacker = Unpacker.Create( stream, PackerUnpackerStreamOptions.SingletonForAsyncUnpacking, DefaultUnpackerOptions );
 			if ( !( await unpacker.ReadAsync( cancellationToken ).ConfigureAwait( false ) ) )
 			{
 				SerializationExceptions.ThrowUnexpectedEndOfStream( unpacker );
diff --git a/test/MsgPack.UnitTest/Serialization/RegressionTests.cs b/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
index ed4cad3ac..bd61a93b6 100644
--- a/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
+++ b/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
@@ -547,5 +547,31 @@ public void TestIssue269()
 			var forString = Assert.Throws<InvalidOperationException>( () => target.AsString() );
 			Assert.That( forString.Message, Is.EqualTo( "Do not convert MsgPack.MessagePackExtendedTypeObject MessagePackObject to System.String." ) );
 		}
+
+#if FEATURE_TAP
+		[Test]
+		public async Task TestIssue321_AsyncBuffering()
+		{
+			var context = new SerializationContext();
+			var serializer = context.GetSerializer<string>();
+			using ( var stream = new MyMemoryStream() ) // could also be a NetworkStream or PipeStream
+			{
+				await serializer.PackAsync( stream, "hello" );
+				TestContext.WriteLine( $"1. Stream now in {stream.Position}" );
+				await serializer.PackAsync( stream, "world" );
+				TestContext.WriteLine( $"2. Stream now in {stream.Position}" );
+				TestContext.WriteLine( Binary.ToHexString( stream.ToArray() ) );
+				stream.Position = 0;
+				var result1 = await serializer.UnpackAsync( stream );
+				TestContext.WriteLine( $"3. Stream now in {stream.Position} -> {result1}" );
+				var result2 = await serializer.UnpackAsync( stream ); // throws MsgPack.InvalidMessagePackStreamException
+				TestContext.WriteLine( $"4. Stream now in {stream.Position} -> {result2}" );
+			}
+		}
+#endif // FEATURE_TAP
+
+		public class MyMemoryStream : MemoryStream
+		{
+		}
 	}
 }

From b9b6991d9345850eae2b4921e997ba6049ae77aa Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 16 Jul 2019 23:51:30 +0900
Subject: [PATCH 21/36] Fix unit test build failure in some targets

This commit removes verbose console logging via TestContext which is not supported in some platforms.
---
 test/MsgPack.UnitTest/Serialization/RegressionTests.cs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/test/MsgPack.UnitTest/Serialization/RegressionTests.cs b/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
index bd61a93b6..ee6330f33 100644
--- a/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
+++ b/test/MsgPack.UnitTest/Serialization/RegressionTests.cs
@@ -554,18 +554,14 @@ public async Task TestIssue321_AsyncBuffering()
 		{
 			var context = new SerializationContext();
 			var serializer = context.GetSerializer<string>();
-			using ( var stream = new MyMemoryStream() ) // could also be a NetworkStream or PipeStream
+			using ( var stream = new MyMemoryStream() )
 			{
 				await serializer.PackAsync( stream, "hello" );
-				TestContext.WriteLine( $"1. Stream now in {stream.Position}" );
 				await serializer.PackAsync( stream, "world" );
-				TestContext.WriteLine( $"2. Stream now in {stream.Position}" );
-				TestContext.WriteLine( Binary.ToHexString( stream.ToArray() ) );
 				stream.Position = 0;
 				var result1 = await serializer.UnpackAsync( stream );
-				TestContext.WriteLine( $"3. Stream now in {stream.Position} -> {result1}" );
-				var result2 = await serializer.UnpackAsync( stream ); // throws MsgPack.InvalidMessagePackStreamException
-				TestContext.WriteLine( $"4. Stream now in {stream.Position} -> {result2}" );
+				// Ensure no exceptions are thrown.
+				var result2 = await serializer.UnpackAsync( stream );
 			}
 		}
 #endif // FEATURE_TAP

From 96aff4d02f196455d45895d2229dd326fa38d63a Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 17 Jul 2019 23:29:39 +0900
Subject: [PATCH 22/36] Add -codedom.yml to avoid CI timeout

---
 appveyor-debug-codedom.yml     | 39 ++++++++++++++++++++++++++++++++++
 build/RunUnitTests-CodeDOM.cmd |  8 +++++++
 build/RunUnitTests.cmd         |  2 --
 3 files changed, 47 insertions(+), 2 deletions(-)
 create mode 100644 appveyor-debug-codedom.yml
 create mode 100644 build/RunUnitTests-CodeDOM.cmd

diff --git a/appveyor-debug-codedom.yml b/appveyor-debug-codedom.yml
new file mode 100644
index 000000000..d4aebb8cc
--- /dev/null
+++ b/appveyor-debug-codedom.yml
@@ -0,0 +1,39 @@
+version: '{branch}-{build}'
+image: Visual Studio 2017
+skip_tags: true
+configuration: Debug
+assembly_info:
+  patch: true
+  file: '**\*AssemblyInfo.cs'
+  assembly_version: $(AssemblyBaseVersion).0
+  assembly_file_version: $(AssemblyBaseVersion).{build}
+  assembly_informational_version: $(PackageVersion)
+environment:
+  XamarinMSBuildExtensionsPath: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild
+install:
+- cmd: >-
+    cd .\build
+- ps: >-
+    ./SetBuildEnv.ps1
+
+    cd ..
+build_script:
+- ps: >-
+    Write-Host "Configuration=${env:CONFIGURATION}"
+
+    cd ./build
+
+    ./Build.ps1
+
+    if ( $LastExitCode -ne 0 )
+    {
+        Write-Error "Failed to build."
+        exit 1
+    }
+
+    cd ..
+test_script:
+- cmd: >-
+    cd ./build
+
+    ./RunUnitTests-CodeDOM.cmd
diff --git a/build/RunUnitTests-CodeDOM.cmd b/build/RunUnitTests-CodeDOM.cmd
new file mode 100644
index 000000000..4274d15f5
--- /dev/null
+++ b/build/RunUnitTests-CodeDOM.cmd
@@ -0,0 +1,8 @@
+dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.CodeDom/MsgPack.UnitTest.CodeDom.csproj
+if not %errorlevel% == 0 exit /b 1
+@rem WinRT related tests require developer license...
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT/AppPackages/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug.appx 
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions.WinRT/AppPackages/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug.appx
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT.WindowsPhone/AppPackages/MsgPack.UnitTest.WinRT.WindowsPhone_1.0.0.0_x86_Debug_Test/MsgPack.UnitTest.WinRT.WindowsPhone_1.0.0.0_x86_Debug.appx 
+@rem UWP test with NUnit3 is not available in cli
+@rem Xamarin tests are not available in cli
\ No newline at end of file
diff --git a/build/RunUnitTests.cmd b/build/RunUnitTests.cmd
index a8f210bdb..2bde04d4f 100644
--- a/build/RunUnitTests.cmd
+++ b/build/RunUnitTests.cmd
@@ -2,8 +2,6 @@ dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest/MsgPack.UnitTest.cspro
 if not %errorlevel% == 0 exit /b 1
 dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj
 if not %errorlevel% == 0 exit /b 1
-dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.CodeDom/MsgPack.UnitTest.CodeDom.csproj
-if not %errorlevel% == 0 exit /b 1
 @rem WinRT related tests require developer license...
 @rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT/AppPackages/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug.appx 
 @rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions.WinRT/AppPackages/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug.appx

From 0761db33e5e80d3d2306ea099e6580bee3909461 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sat, 20 Jul 2019 01:09:37 +0900
Subject: [PATCH 23/36] Add more appveyor-x.yml files to improve CI stability

---
 appveyor-debug-netcore10.yml     | 39 ++++++++++++++++++++++++++++++++
 appveyor-debug4x.yml             | 39 ++++++++++++++++++++++++++++++++
 build/RunUnitTests-NetCore10.cmd | 10 ++++++++
 build/RunUnitTests.cmd           |  4 ++--
 build/RunUnitTests4x.cmd         | 10 ++++++++
 5 files changed, 100 insertions(+), 2 deletions(-)
 create mode 100644 appveyor-debug-netcore10.yml
 create mode 100644 appveyor-debug4x.yml
 create mode 100644 build/RunUnitTests-NetCore10.cmd
 create mode 100644 build/RunUnitTests4x.cmd

diff --git a/appveyor-debug-netcore10.yml b/appveyor-debug-netcore10.yml
new file mode 100644
index 000000000..5389a70c0
--- /dev/null
+++ b/appveyor-debug-netcore10.yml
@@ -0,0 +1,39 @@
+version: '{branch}-{build}'
+image: Visual Studio 2017
+skip_tags: true
+configuration: Debug
+assembly_info:
+  patch: true
+  file: '**\*AssemblyInfo.cs'
+  assembly_version: $(AssemblyBaseVersion).0
+  assembly_file_version: $(AssemblyBaseVersion).{build}
+  assembly_informational_version: $(PackageVersion)
+environment:
+  XamarinMSBuildExtensionsPath: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild
+install:
+- cmd: >-
+    cd .\build
+- ps: >-
+    ./SetBuildEnv.ps1
+
+    cd ..
+build_script:
+- ps: >-
+    Write-Host "Configuration=${env:CONFIGURATION}"
+
+    cd ./build
+
+    ./Build.ps1
+
+    if ( $LastExitCode -ne 0 )
+    {
+        Write-Error "Failed to build."
+        exit 1
+    }
+
+    cd ..
+test_script:
+- cmd: >-
+    cd ./build
+
+    ./RunUnitTests-NetCore10.cmd
diff --git a/appveyor-debug4x.yml b/appveyor-debug4x.yml
new file mode 100644
index 000000000..66fff7217
--- /dev/null
+++ b/appveyor-debug4x.yml
@@ -0,0 +1,39 @@
+version: '{branch}-{build}'
+image: Visual Studio 2017
+skip_tags: true
+configuration: Debug
+assembly_info:
+  patch: true
+  file: '**\*AssemblyInfo.cs'
+  assembly_version: $(AssemblyBaseVersion).0
+  assembly_file_version: $(AssemblyBaseVersion).{build}
+  assembly_informational_version: $(PackageVersion)
+environment:
+  XamarinMSBuildExtensionsPath: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild
+install:
+- cmd: >-
+    cd .\build
+- ps: >-
+    ./SetBuildEnv.ps1
+
+    cd ..
+build_script:
+- ps: >-
+    Write-Host "Configuration=${env:CONFIGURATION}"
+
+    cd ./build
+
+    ./Build.ps1
+
+    if ( $LastExitCode -ne 0 )
+    {
+        Write-Error "Failed to build."
+        exit 1
+    }
+
+    cd ..
+test_script:
+- cmd: >-
+    cd ./build
+
+    ./RunUnitTests4x.cmd
diff --git a/build/RunUnitTests-NetCore10.cmd b/build/RunUnitTests-NetCore10.cmd
new file mode 100644
index 000000000..b1ec28612
--- /dev/null
+++ b/build/RunUnitTests-NetCore10.cmd
@@ -0,0 +1,10 @@
+dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj --framework netcoreapp1.0
+if not %errorlevel% == 0 exit /b 1
+dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj --framework netcoreapp1.0
+if not %errorlevel% == 0 exit /b 1
+@rem WinRT related tests require developer license...
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT/AppPackages/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug.appx 
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions.WinRT/AppPackages/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug.appx
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT.WindowsPhone/AppPackages/MsgPack.UnitTest.WinRT.WindowsPhone_1.0.0.0_x86_Debug_Test/MsgPack.UnitTest.WinRT.WindowsPhone_1.0.0.0_x86_Debug.appx 
+@rem UWP test with NUnit3 is not available in cli
+@rem Xamarin tests are not available in cli
\ No newline at end of file
diff --git a/build/RunUnitTests.cmd b/build/RunUnitTests.cmd
index 2bde04d4f..ed3e8884c 100644
--- a/build/RunUnitTests.cmd
+++ b/build/RunUnitTests.cmd
@@ -1,6 +1,6 @@
-dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj
+dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj --framework netcoreapp2.0
 if not %errorlevel% == 0 exit /b 1
-dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj
+dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj --framework netcoreapp2.0
 if not %errorlevel% == 0 exit /b 1
 @rem WinRT related tests require developer license...
 @rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT/AppPackages/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug.appx 
diff --git a/build/RunUnitTests4x.cmd b/build/RunUnitTests4x.cmd
new file mode 100644
index 000000000..4b1b79408
--- /dev/null
+++ b/build/RunUnitTests4x.cmd
@@ -0,0 +1,10 @@
+dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj --framework net47
+if not %errorlevel% == 0 exit /b 1
+dotnet test %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj --framework net47
+if not %errorlevel% == 0 exit /b 1
+@rem WinRT related tests require developer license...
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT/AppPackages/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.WinRT_1.1.0.0_AnyCPU_Debug.appx 
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.BclExtensions.WinRT/AppPackages/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug_Test/MsgPack.UnitTest.BclExtensions.WinRT_1.1.0.0_AnyCPU_Debug.appx
+@rem vstest.console /logger:Appveyor /InIsolation %APPVEYOR_BUILD_FOLDER%/test/MsgPack.UnitTest.WinRT.WindowsPhone/AppPackages/MsgPack.UnitTest.WinRT.WindowsPhone_1.0.0.0_x86_Debug_Test/MsgPack.UnitTest.WinRT.WindowsPhone_1.0.0.0_x86_Debug.appx 
+@rem UWP test with NUnit3 is not available in cli
+@rem Xamarin tests are not available in cli
\ No newline at end of file

From e47b39c853875a89c3afdeeb4fda96db65b509f6 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sat, 20 Jul 2019 01:09:58 +0900
Subject: [PATCH 24/36] Update readme to add badges for new CI builds

---
 README.md | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index f84d6b047..086e0a668 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,13 @@
 # MessagePack for CLI
 
 [![Build status release](https://ci.appveyor.com/api/projects/status/5ln7u7efwjepj6o8?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-x2p85)
-[![Build status debug](https://ci.appveyor.com/api/projects/status/dlc0v4rrolwj0t2t?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli)
-[![Build status debug net35](https://ci.appveyor.com/api/projects/status/cjp8phlnbwj7gkj9?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-3jme9)
-[![Build status debug net35 CodeDOM](https://ci.appveyor.com/api/projects/status/1mw78wkxx50jvab1?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-rhnh0)
+[![Build status debug (.NET Core 2.0)](https://ci.appveyor.com/api/projects/status/dlc0v4rrolwj0t2t?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli)
+[![Build status debug (.NET Core 1.0)](https://ci.appveyor.com/api/projects/status/avurf519all92v5u?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-g3guk)
+[![Build status debug (.NET Framework 4.x)](https://ci.appveyor.com/api/projects/status/np6723q2uiqofr1a?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-nuf62)
+[![Build status debug (Code DOM)](https://ci.appveyor.com/api/projects/status/1mw78wkxx50jvab1?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-rhnh0)
+[![Build status debug (miscs)](https://ci.appveyor.com/api/projects/status/avufc51yu2cm6idw?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-bo856)
+[![Build status debug (.NET Framework 3.5)](https://ci.appveyor.com/api/projects/status/cjp8phlnbwj7gkj9?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-3jme9)
+[![Build status debug (.NET Framework 3.5 Code DOM)](https://ci.appveyor.com/api/projects/status/1mw78wkxx50jvab1?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-rhnh0)
 
 ## What is it?
 

From 45e7c47bc0b4e7f52d55fcce162f2ef86d6db965 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 21 Jul 2019 16:41:05 +0900
Subject: [PATCH 25/36] Clarify Q&A of readme

---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 086e0a668..104136f50 100644
--- a/README.md
+++ b/README.md
@@ -122,8 +122,8 @@ Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V-Hypervisor
 
 #### Xamarin Android Trouble shooting tips
 
-* Javac shows compilation error.
-    * Rebuild the test project and try it run again.
+* **Q:** Javac shows compilation error.
+    * **A:** Rebuild the test project and try it run again.
 
 ### Xamarin iOS testing
 
@@ -145,10 +145,10 @@ There are bundle IDs of current iOS tests:
 
 See [Xamarin's official trouble shooting docs first.](https://developer.xamarin.com/guides/ios/getting_started/installation/windows/connecting-to-mac/troubleshooting/)
 
-* An error occurred while running unit test project.
-    * Rebuild the project and rerun it. Or, login your Mac again, ant retry it.
-* It is hard to read English.
-    * You can read localized Xamarin docs with putting `{region}-{lang}` as the first component of URL path such as `https://developer.xamarin.com/ja-jp/guides/...`.
+* **Q:** An error occurred while running unit test project.
+    * **A:** Rebuild the project and rerun it. Or, login your Mac again, ant retry it.
+* **Q:** It is hard to read English.
+    * **A:** You can read localized Xamarin docs with putting `{region}-{lang}` as the first component of URL path such as `https://developer.xamarin.com/ja-jp/guides/...`.
 
 ## See also
 

From 66734ae4ab29e43e87458147e46442da15bf8ec6 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 21 Jul 2019 18:52:29 +0900
Subject: [PATCH 26/36] Add AOT related note

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 104136f50..829197721 100644
--- a/README.md
+++ b/README.md
@@ -49,7 +49,7 @@ Dim unpackedObject = serializer.Unpack(stream)
 * Flexible MessagePackObject which represents MessagePack type system naturally.
 
 **Note: AOT support is limited yet. Use [serializer pre-generation](https://github.com/msgpack/msgpack-cli/wiki/Xamarin-and-Unity) with `mpu -s` utility or API.**  
-If you do not pre-generated serializers, MsgPack for CLI uses reflection in AOT environments, it is slower and it sometimes causes AOT related error (`ExecutionEngineException` for runtime JIT compilation).
+If you do not pre-generated serializers, MsgPack for CLI uses reflection in AOT environments, it is slower and it sometimes causes AOT related error (`ExecutionEngineException` for runtime JIT compilation). **You also have to call `MessagePackSerializer.PrepareType<T>` and companions in advance to avoid AOT related error.** See [wiki](https://github.com/msgpack/msgpack-cli/wiki/Xamarin-and-Unity) for details.
 
 ## Documentation
 

From 76b8b4ba4bec9bd44492c693dde2b4821a877006 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 21 Jul 2019 18:52:42 +0900
Subject: [PATCH 27/36] Cosmetic changes

---
 README.md | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index 829197721..15bbe6c6b 100644
--- a/README.md
+++ b/README.md
@@ -17,10 +17,11 @@ This library can be used from ALL CLS compliant languages such as C#, F#, Visual
 ## Usage
 
 You can serialize/deserialize objects as following:
+
 1. Create serializer via `MessagePackSerializer.Get` generic method. This method creates dependent types serializers as well.
-1. Invoke serializer as following:
-** `Pack` method with destination `Stream` and target object for serialization.
-** `Unpack` method with source `Stream`.
+2. Invoke serializer as following:
+  * `Pack` method with destination `Stream` and target object for serialization.
+  * `Unpack` method with source `Stream`.
 
 ```c#
 // Creates serializer.
@@ -111,11 +112,13 @@ If you want to use ".NET 2.0 Subset" settings, you must use just only described
 
 If you run on Windows, it is recommended to use HXM instead of Hyper-V based emulator.  
 You can disable Hyper-V from priviledged (administrator) powershell as follows:
+
 ```powershell
 Disable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V-Hypervisor
 ```
 
 If you want to use Hyper-V again (such as for Docker for Windows etc.), you can do it by following in priviledged (administrator) powershell:
+
 ```powershell
 Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V-Hypervisor
 ```
@@ -123,7 +126,7 @@ Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V-Hypervisor
 #### Xamarin Android Trouble shooting tips
 
 * **Q:** Javac shows compilation error.
-    * **A:** Rebuild the test project and try it run again.
+  * **A:** Rebuild the test project and try it run again.
 
 ### Xamarin iOS testing
 
@@ -131,6 +134,7 @@ You must create provisoning profiles in your MacOS devices.
 See [Xamarin documents about provisining](https://developer.xamarin.com/guides/ios/getting_started/installation/device_provisioning/free-provisioning/) for details.
 
 There are bundle IDs of current iOS tests:
+
 * `org.msgpack.msgpack-cli-xamarin-ios-test`
 * `org.msgpack.msgpack-cli-xamarin-ios-test-packer`
 * `org.msgpack.msgpack-cli-xamarin-ios-test-unpacker`
@@ -146,15 +150,15 @@ There are bundle IDs of current iOS tests:
 See [Xamarin's official trouble shooting docs first.](https://developer.xamarin.com/guides/ios/getting_started/installation/windows/connecting-to-mac/troubleshooting/)
 
 * **Q:** An error occurred while running unit test project.
-    * **A:** Rebuild the project and rerun it. Or, login your Mac again, ant retry it.
+  * **A:** Rebuild the project and rerun it. Or, login your Mac again, ant retry it.
 * **Q:** It is hard to read English.
-    * **A:** You can read localized Xamarin docs with putting `{region}-{lang}` as the first component of URL path such as `https://developer.xamarin.com/ja-jp/guides/...`.
+  * **A:** You can read localized Xamarin docs with putting `{region}-{lang}` as the first component of URL path such as `https://developer.xamarin.com/ja-jp/guides/...`.
 
 ## See also
 
-*  GitHub Page           : http://cli.msgpack.org/
-*  Wiki (documentation)  : https://github.com/msgpack/msgpack-cli/wiki
-*  API Reference         : http://cli.msgpack.org/doc/top.html
-*  Issue tracker         : https://github.com/msgpack/msgpack-cli/issues
-*  MSBuild reference     : http://msdn.microsoft.com/en-us/library/0k6kkbsd.aspx
-*  Mono xbuild reference : http://www.mono-project.com/Microsoft.Build
+* GitHub Page           : http://cli.msgpack.org/
+* Wiki (documentation)  : https://github.com/msgpack/msgpack-cli/wiki
+* API Reference         : http://cli.msgpack.org/doc/top.html
+* Issue tracker         : https://github.com/msgpack/msgpack-cli/issues
+* MSBuild reference     : http://msdn.microsoft.com/en-us/library/0k6kkbsd.aspx
+* Mono xbuild reference : http://www.mono-project.com/Microsoft.Build

From 4c72b665c9c324167f4717b5c761faef5176b59c Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 22 Jul 2019 20:47:01 +0900
Subject: [PATCH 28/36] Fix badges to clarify configuration

---
 README.md | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 15bbe6c6b..eeb265850 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,17 @@
 # MessagePack for CLI
 
-[![Build status release](https://ci.appveyor.com/api/projects/status/5ln7u7efwjepj6o8?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-x2p85)
-[![Build status debug (.NET Core 2.0)](https://ci.appveyor.com/api/projects/status/dlc0v4rrolwj0t2t?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli)
-[![Build status debug (.NET Core 1.0)](https://ci.appveyor.com/api/projects/status/avurf519all92v5u?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-g3guk)
-[![Build status debug (.NET Framework 4.x)](https://ci.appveyor.com/api/projects/status/np6723q2uiqofr1a?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-nuf62)
-[![Build status debug (Code DOM)](https://ci.appveyor.com/api/projects/status/1mw78wkxx50jvab1?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-rhnh0)
-[![Build status debug (miscs)](https://ci.appveyor.com/api/projects/status/avufc51yu2cm6idw?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-bo856)
-[![Build status debug (.NET Framework 3.5)](https://ci.appveyor.com/api/projects/status/cjp8phlnbwj7gkj9?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-3jme9)
-[![Build status debug (.NET Framework 3.5 Code DOM)](https://ci.appveyor.com/api/projects/status/1mw78wkxx50jvab1?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-rhnh0)
+## CI Status
+
+|**Configuration**|**Status**|
+|:--|:--|
+|Release                             |[![Build status release](https://ci.appveyor.com/api/projects/status/5ln7u7efwjepj6o8?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-x2p85)|
+|Debug (.NET Core 2.0)               |[![Build status debug (.NET Core 2.0)](https://ci.appveyor.com/api/projects/status/dlc0v4rrolwj0t2t?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli)|
+|Debug (.NET Core 2.0)               |[![Build status debug (.NET Core 1.0)](https://ci.appveyor.com/api/projects/status/avurf519all92v5u?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-g3guk)|
+|Debug (.NET Framework 4.x)          |[![Build status debug (.NET Framework 4.x)](https://ci.appveyor.com/api/projects/status/np6723q2uiqofr1a?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-nuf62)|
+|Debug (Code DOM)]                   |[![Build status debug (Code DOM)](https://ci.appveyor.com/api/projects/status/1mw78wkxx50jvab1?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-rhnh0)|
+|Debug (miscs)]                      |[![Build status debug (miscs)](https://ci.appveyor.com/api/projects/status/avufc51yu2cm6idw?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-bo856)|
+|Debug (.NET Framework 3.5)          |[![Build status debug (.NET Framework 3.5)](https://ci.appveyor.com/api/projects/status/cjp8phlnbwj7gkj9?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-3jme9)|
+|Debug (.NET Framework 3.5 Code DOM) |[![Build status debug (.NET Framework 3.5 Code DOM)](https://ci.appveyor.com/api/projects/status/1mw78wkxx50jvab1?svg=true)](https://ci.appveyor.com/project/yfakariya/msgpack-cli-rhnh0)|
 
 ## What is it?
 

From a084174df9ea21f9ebdba456534c613920658d47 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 14 Oct 2019 22:19:39 +0900
Subject: [PATCH 29/36] Update readme about silverlight/winrt/uwp projects.

---
 README.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/README.md b/README.md
index eeb265850..d6253d7ee 100644
--- a/README.md
+++ b/README.md
@@ -158,6 +158,15 @@ See [Xamarin's official trouble shooting docs first.](https://developer.xamarin.
 * **Q:** It is hard to read English.
   * **A:** You can read localized Xamarin docs with putting `{region}-{lang}` as the first component of URL path such as `https://developer.xamarin.com/ja-jp/guides/...`.
 
+## Maintenance
+
+### MsgPack.Windows.sln
+
+This solution contains Silverlight5 and (old) UWP project for backward compability. They are required Visual Studio 2015 to build and test.  
+You can download Visual Studio 2015 community edition from [here](https://visualstudio.microsoft.com/vs/older-downloads/).
+
+**You do not have to install Visual Studio 2015 as long as you don't edit/test/build Silverlight and/or old UWP project.**
+
 ## See also
 
 * GitHub Page           : http://cli.msgpack.org/

From e7514259edd2f38378d3ea1b3de57587dfa7d75b Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 14 Oct 2019 22:21:25 +0900
Subject: [PATCH 30/36] Add test cert tool

This tool solves a problem that Visual Studio only generates 1-year expiry certs.
By this commit, dev-certs will have expiry until 2038.
In that time, UWP apps should be replaced completely.
---
 tools/MakeCert/New-TestCerft.ps1 | 49 ++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 tools/MakeCert/New-TestCerft.ps1

diff --git a/tools/MakeCert/New-TestCerft.ps1 b/tools/MakeCert/New-TestCerft.ps1
new file mode 100644
index 000000000..abb42dcef
--- /dev/null
+++ b/tools/MakeCert/New-TestCerft.ps1
@@ -0,0 +1,49 @@
+<#
+.SYNOPSIS
+Make test certificate for UWP unit test programs.
+.PARAMETER FilePath
+Specify output file path. Default is "./testcert.pfx"
+.DESCRIPTION
+This script makes self-signed certificates for code signing with CN=MsgPack.Cli.UnitTest, RSA256, SHA256 with maximum expiry date.
+Note that the pfx file has empty password.
+#>
+#requires -Version 5.1
+
+using namespace System.IO
+using namespace System.Security.Cryptography
+using namespace System.Security.Cryptography.X509Certificates
+
+[CmdletBinding(PositionalBinding = $false)]
+param(
+    [ValidateNotNullOrEmpty()][string]$FilePath = "./testcert.pfx"
+)
+
+Set-StrictMode -Version 5.1
+
+[string]$subject = "CN=MsgPack.Cli.UnitTest"
+[RSA]$password = [RSA]::Create(2048)
+[HashAlgorithmName]$hashAlgorithm = [HashAlgorithmName]::SHA256
+[RSASignaturePadding]$padding = [RSASignaturePadding]::Pkcs1
+[DateTimeOffset]$notBefore = [System.DateTimeOffset]::new(2019, 10, 1, 0, 0, 0, 0)
+# Some implementation has year 2037 problem, they cannot accept date after 2038/01/19.
+[DateTimeOffset]$notAfter = [System.DateTimeOffset]::FromUnixTimeSeconds([Int32]::MaxValue)
+
+# Try load CertificateRequest type dinamically to support multiple platforms...
+$certReqType = [System.Linq.Enumerable].Assembly.GetType("System.Security.Cryptography.X509Certificates.CertificateRequest")
+if ($null -eq $certReqType) {
+	# This should be pwsh
+	$certReqType = [X509Certificate].Assembly.GetType("System.Security.Cryptography.X509Certificates.CertificateRequest")
+	if ($null -eq $certReqType) {
+        throw [PlatformNotSupportedException]::new("pwsh, or PowerShell with .NET Framework 4.7.2 or later is required.");
+    }
+}
+
+# Create CertificateRequest instance
+$certReq = $certReqType::new($subject, $password, $hashAlgorithm, $padding)
+# This cert is for code signing: 
+$certReq.CertificateExtensions.Add([X509EnhancedKeyUsageExtension]::new([X509Extension]::new([Oid]::FromOidValue("2.5.29.37", [OidGroup]::All ), @(48, 10, 6, 8, 43, 6, 1, 5, 5, 7, 3, 3), $true), $true))
+# This cert is end entity: 2.5.29.19, {48,0}, critical.
+$certReq.CertificateExtensions.Add([X509BasicConstraintsExtension]::new([X509Extension]::new([Oid]::FromOidValue("2.5.29.19", [OidGroup]::All ), @(48, 0), $true), $true))
+
+[X509Certificate2]$cert = $certReq.CreateSelfSigned($notBefore, $notAfter)
+[File]::WriteAllBytes($FilePath, $cert.Export([X509ContentType]::Pfx, [String]::Empty))

From 0be7d578826f5784dee5181562279dec0b4bc23b Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 14 Oct 2019 22:22:06 +0900
Subject: [PATCH 31/36] Update development certificates to year 2038 expiry.

---
 ...tTest.BclExtensions.WinRT_TemporaryKey.pfx | Bin 2536 -> 2422 bytes
 .../MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx | Bin 2536 -> 2422 bytes
 .../MsgPack.UnitTest.Uwp_TemporaryKey.pfx     | Bin 2536 -> 2422 bytes
 .../MsgPack.UnitTest.WinRT_TemporaryKey.pfx   | Bin 2536 -> 2422 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx b/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx
index 9c3c1d01314c6908e274dbc71ada95c708e87f6a..d2def697cc44b6e03d179dd068c447c95898b2a5 100644
GIT binary patch
literal 2422
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
L)Uf*K&yV+S91C0A

literal 2536
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

diff --git a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx
index 8a0d0bd470c6ec815e7ac310d4683765e23db5e3..d2def697cc44b6e03d179dd068c447c95898b2a5 100644
GIT binary patch
literal 2422
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
L)Uf*K&yV+S91C0A

literal 2536
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

diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx
index 604dac0b06b2be4477b423f66665c174ef9a9e0e..d2def697cc44b6e03d179dd068c447c95898b2a5 100644
GIT binary patch
delta 2385
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
D17BSJ

literal 2536
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

diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx
index 194d5586e4ba259a8dfd83a5fd24003c06e36e8b..d2def697cc44b6e03d179dd068c447c95898b2a5 100644
GIT binary patch
delta 2385
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
D17BSJ

literal 2536
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


From e2dd99f34d7f8c7322b6959391b5ecfed90e4ed3 Mon Sep 17 00:00:00 2001
From: Hodaifa98 <40869908+Hodaifa98@users.noreply.github.com>
Date: Tue, 20 Oct 2020 14:51:36 +0100
Subject: [PATCH 32/36] Changed "pacakge" to "package".

Fixed a simple typo I saw when browsing .net packages.
---
 MsgPack.nuspec | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MsgPack.nuspec b/MsgPack.nuspec
index aa088e4d2..1030c7002 100644
--- a/MsgPack.nuspec
+++ b/MsgPack.nuspec
@@ -11,7 +11,7 @@
     <iconUrl>http://cli.msgpack.org/images/msgpack.ico</iconUrl>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>MessagePack is fast, compact, and interoperable binary serialization format.
-This package provides MessagePack serialization/deserialization APIs. This pacakge also supports Mono, Xamarin, .NET Core and Unity.</description>
+This package provides MessagePack serialization/deserialization APIs. This package also supports Mono, Xamarin, .NET Core and Unity.</description>
     <releaseNotes>This release includes .NET Core and Unity IL2CPP support, Xamarin iOS linker support, asynchronous serialization support, and various improvements and bug fixes reported in github issues.</releaseNotes>
     <copyright>Copyright 2010-2016 FUJIWARA, Yusuke, all rights reserved.</copyright>
     <tags>MsgPack MessagePack Serialization Formatter Serializer</tags>

From bec12b0f7ac9eb2c06c29d73ec71bb1259802f46 Mon Sep 17 00:00:00 2001
From: southernsun <southernsun@users.noreply.github.com>
Date: Tue, 6 Apr 2021 10:57:40 +0200
Subject: [PATCH 33/36] Update Sample08_Polymorphism.cs

---
 samples/Samples/Sample08_Polymorphism.cs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/samples/Samples/Sample08_Polymorphism.cs b/samples/Samples/Sample08_Polymorphism.cs
index c3179cfc9..587216001 100644
--- a/samples/Samples/Sample08_Polymorphism.cs
+++ b/samples/Samples/Sample08_Polymorphism.cs
@@ -56,11 +56,7 @@ public void Polymorphism()
 			using ( var buffer = new MemoryStream() )
 			{
 				serializer.Pack(
-					buffer, new PolymorphicHolder
-					{
-						WithRuntimeType = new FileObject { Path = "/path/to/file" },
-						WithKnownType = new DirectoryObject { Path = "/path/to/dir/" }
-					}
+					buffer, rootObject	
 				);
 
 				buffer.Position = 0;
@@ -200,4 +196,4 @@ public static bool Verify( PolymorphicTypeVerificationContext context )
 			return true;
 		}
 	}
-}
\ No newline at end of file
+}

From 392d92038b1036e65b4177a1276a29f6faf5ad33 Mon Sep 17 00:00:00 2001
From: Akira Takahashi <faithandbrave@gmail.com>
Date: Fri, 7 Apr 2023 13:50:16 +0900
Subject: [PATCH 34/36] fix bad DateTime sample

---
 samples/Samples/Sample01_BasicUsage.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/samples/Samples/Sample01_BasicUsage.cs b/samples/Samples/Sample01_BasicUsage.cs
index 84c37be96..559da1ef1 100644
--- a/samples/Samples/Sample01_BasicUsage.cs
+++ b/samples/Samples/Sample01_BasicUsage.cs
@@ -1,4 +1,4 @@
-#region -- License Terms --
+#region -- License Terms --
 //
 // MessagePack for CLI
 //
@@ -69,7 +69,7 @@ public void SerializeThenDeserialize()
 			Debug.WriteLine( "Same Id? {0}", targetObject.Id == deserializedObject.Id );
 			Debug.WriteLine( "Same Title? {0}", targetObject.Title == deserializedObject.Title );
 			// Note that MsgPack defacto-standard is Unix epoc in milliseconds precision, so micro- and nano- seconds will be lost. See sample 04 for workaround.
-			Debug.WriteLine( "Same Date? {0}", targetObject.Date.ToString( "YYYY-MM-DD HH:mm:ss.fff" ) == deserializedObject.Date.ToString( "YYYY-MM-DD HH:mm:ss.fff" ) );
+			Debug.WriteLine( "Same Date? {0}", targetObject.Date.ToString( "yyyy-MM-dd HH:mm:ss.fff" ) == deserializedObject.Date.ToLocalTime().ToString( "yyyy-MM-dd HH:mm:ss.fff" ) );
 			// Image and Comment tests are ommitted here.
 			// Collection elements are deserialzed.
 			Debug.WriteLine( "Items count: {0}", deserializedObject.Tags.Count );

From fe47c7df4e31460f3ea2e24d0f822062717357a3 Mon Sep 17 00:00:00 2001
From: Akira Takahashi <faithandbrave@gmail.com>
Date: Fri, 7 Apr 2023 23:48:30 +0900
Subject: [PATCH 35/36] use DateTime.UtcNow

---
 samples/Samples/Sample01_BasicUsage.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/samples/Samples/Sample01_BasicUsage.cs b/samples/Samples/Sample01_BasicUsage.cs
index 559da1ef1..37c660a08 100644
--- a/samples/Samples/Sample01_BasicUsage.cs
+++ b/samples/Samples/Sample01_BasicUsage.cs
@@ -44,7 +44,7 @@ public void SerializeThenDeserialize()
 				{
 					Id = 123,
 					Title = "My photo",
-					Date = DateTime.Now,
+					Date = DateTime.UtcNow,
 					Image = new byte[] { 1, 2, 3, 4 },
 					Comment = "This is test object to be serialize/deserialize using MsgPack."
 				};
@@ -69,7 +69,7 @@ public void SerializeThenDeserialize()
 			Debug.WriteLine( "Same Id? {0}", targetObject.Id == deserializedObject.Id );
 			Debug.WriteLine( "Same Title? {0}", targetObject.Title == deserializedObject.Title );
 			// Note that MsgPack defacto-standard is Unix epoc in milliseconds precision, so micro- and nano- seconds will be lost. See sample 04 for workaround.
-			Debug.WriteLine( "Same Date? {0}", targetObject.Date.ToString( "yyyy-MM-dd HH:mm:ss.fff" ) == deserializedObject.Date.ToLocalTime().ToString( "yyyy-MM-dd HH:mm:ss.fff" ) );
+			Debug.WriteLine( "Same Date? {0}", targetObject.Date.ToString( "yyyy-MM-dd HH:mm:ss.fff" ) == deserializedObject.Date.ToString( "yyyy-MM-dd HH:mm:ss.fff" ) );
 			// Image and Comment tests are ommitted here.
 			// Collection elements are deserialzed.
 			Debug.WriteLine( "Items count: {0}", deserializedObject.Tags.Count );

From a6d86ad4a433ff0d6deb592b315feb4ea9149e6b Mon Sep 17 00:00:00 2001
From: James Thompson <thompson.tomo@outlook.com>
Date: Wed, 17 Apr 2024 08:28:01 +1000
Subject: [PATCH 36/36] #359 add net core 3.1 & net 6

---
 src/MsgPack/MsgPack.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/MsgPack/MsgPack.csproj b/src/MsgPack/MsgPack.csproj
index 783b86a89..d503aedb1 100644
--- a/src/MsgPack/MsgPack.csproj
+++ b/src/MsgPack/MsgPack.csproj
@@ -4,7 +4,7 @@
     <ProjectGuid>{5BCEC32E-990E-4DE5-945F-BD27326A7418}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AssemblyName>MsgPack</AssemblyName>
-    <TargetFrameworks>net46;net35;net45;netstandard1.1;netstandard1.3;netstandard2.0;MonoAndroid10;Xamarin.iOS10;</TargetFrameworks>
+    <TargetFrameworks>net46;net35;net45;netstandard1.1;netstandard1.3;netstandard2.0;MonoAndroid10;Xamarin.iOS10;netcoreapp3.1;net6.0</TargetFrameworks>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <NuspecFile>$(SolutionDir)/msgpack.nuspec</NuspecFile>
@@ -16,7 +16,7 @@
   <PropertyGroup Condition="'$(Configuration)' != 'Release'">
     <OutputPath>bin\$(Configuration)\</OutputPath>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'uap10.0' and '$(TargetFramework)' != 'netstandard1.1' and '$(TargetFramework)' != 'netstandard1.3' and '$(TargetFramework)' != 'netstandard2.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net35' or '$(TargetFramework)'== 'net45' or '$(TargetFramework)' == 'net46'">
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Numerics" Condition="'$(TargetFramework)' != 'net35'" />