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/12] 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/12] 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/12] 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/12] 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/12] 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/12] 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/12] 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/12] 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/12] 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/12] 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/12] 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/12] 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.*")