diff --git a/CHANGES.txt b/CHANGES.txt index 0de4aca8e..9dffa6710 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -753,3 +753,17 @@ 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 + +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/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"}, 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 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.*") diff --git a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj index 45b5284a5..f8d9dc0c1 100644 --- a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj +++ b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj @@ -245,6 +245,9 @@ Serialization\ReflectionExtensions.ConstructorDelegate.cs + + Serialization\BindingOptions.cs + Serialization\CollectionDetailedKind.cs @@ -671,11 +674,11 @@ Serialization\ResolveSerializerEventArgs.cs + + Serialization\SerializationCompatibilityLevel.cs + Serialization\SerializationCompatibilityOptions.cs - - - Serialization\BindingOptions.cs Serialization\SerializationContext.cs diff --git a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj index 399b5796f..13939a92b 100644 --- a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj +++ b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj @@ -216,6 +216,9 @@ ReflectionAbstractions.cs + + Serialization\BindingOptions.cs + Serialization\CollectionDetailedKind.cs @@ -678,11 +681,11 @@ Serialization\ResolveSerializerEventArgs.cs + + Serialization\SerializationCompatibilityLevel.cs + Serialization\SerializationCompatibilityOptions.cs - - - Serialization\BindingOptions.cs Serialization\SerializationContext.cs diff --git a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj index 00a022cb8..c7665009a 100644 --- a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj +++ b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj @@ -220,6 +220,9 @@ Serialization\Tracer.cs + + Serialization\BindingOptions.cs + Serialization\CollectionDetailedKind.cs @@ -649,11 +652,11 @@ Serialization\ResolveSerializerEventArgs.cs + + Serialization\SerializationCompatibilityLevel.cs + Serialization\SerializationCompatibilityOptions.cs - - - Serialization\BindingOptions.cs Serialization\SerializationContext.cs diff --git a/src/MsgPack.Unity/MsgPack.Unity.csproj b/src/MsgPack.Unity/MsgPack.Unity.csproj index 53ca4e7a3..8d8d7361f 100644 --- a/src/MsgPack.Unity/MsgPack.Unity.csproj +++ b/src/MsgPack.Unity/MsgPack.Unity.csproj @@ -234,13 +234,13 @@ ReflectionAbstractions.cs - - - Serialization\BindingOptions.cs Serialization\Tracer.cs + + Serialization\BindingOptions.cs + Serialization\CollectionDetailedKind.cs @@ -658,6 +658,9 @@ Serialization\ResolveSerializerEventArgs.cs + + Serialization\SerializationCompatibilityLevel.cs + Serialization\SerializationCompatibilityOptions.cs diff --git a/src/MsgPack.Uwp/MsgPack.Uwp.csproj b/src/MsgPack.Uwp/MsgPack.Uwp.csproj index f32d07373..6865b97e6 100644 --- a/src/MsgPack.Uwp/MsgPack.Uwp.csproj +++ b/src/MsgPack.Uwp/MsgPack.Uwp.csproj @@ -244,6 +244,9 @@ ReflectionAbstractions.cs + + Serialization\BindingOptions.cs + Serialization\CollectionDetailedKind.cs @@ -721,11 +724,11 @@ Serialization\ResolveSerializerEventArgs.cs + + Serialization\SerializationCompatibilityLevel.cs + Serialization\SerializationCompatibilityOptions.cs - - - Serialization\BindingOptions.cs Serialization\SerializationContext.cs 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 { /// - /// Private mapping of types & their member skip list, which needs to ignore as part of serialization. + /// Private mapping of types & their member skip list, which needs to ignore as part of serialization. /// - private readonly IDictionary> typeIgnoringMembersMap = new Dictionary>(); + private readonly IDictionary> _typeIgnoringMembersMap = new Dictionary>(); /// /// Sets the member skip list for a specific target type. @@ -45,15 +44,15 @@ public class BindingOptions /// The member skip list. public void SetIgnoringMembers( Type targetType, IEnumerable 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 memberSkipL /// Returns member skip list for a specific target type. public IEnumerable 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 GetIgnoringMembers( Type targetType ) /// Returns all registered types specific ignoring members. public IDictionary> GetAllIgnoringMembers() { - lock ( this.typeIgnoringMembersMap ) + lock ( this._typeIgnoringMembersMap ) { - return this.typeIgnoringMembersMap.ToDictionary( item => item.Key, item => ( IEnumerable )item.Value.ToArray() ); + return this._typeIgnoringMembersMap.ToDictionary( item => item.Key, item => ( IEnumerable )item.Value.ToArray() ); } } } 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 +{ + /// + /// Represents compatibility level. + /// + public enum SerializationCompatibilityLevel + { + /// + /// Use latest feature. Almost backward compatible, but some compatibities are broken. + /// + Latest = 0, + + /// + /// Compatible for version 0.5.x or former. + /// + Version0_5, + + /// + /// Compatible for version 0.6.x, 0.7.x, 0.8.x, and 0.9.x. + /// + Version0_9 + } +} diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs index 1a91f72dd..8d445eb4f 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(); @@ -478,14 +478,26 @@ private MessagePackSerializer OnResolveSerializer( PolymorphismSchema sche } /// - /// Configures as new classic instance. + /// Configures as new classic instance as compatible for ver 0.5. /// /// The previously set context as . /// + [Obsolete( "Use ConfigureClassic(SerializationCompatibilityLevel) instead." )] public static SerializationContext ConfigureClassic() { + return ConfigureClassic( SerializationCompatibilityLevel.Version0_5 ); + } + + /// + /// Configures as new classic instance as compatible for sepcified version. + /// + /// A to specify compatibility level. + /// The previously set context as . + /// + 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() /// /// A new which is configured as same as 0.5. /// + [Obsolete( "Use CreateClassicContext(SerializationCompatibilityLevel) instead." )] + public static SerializationContext CreateClassicContext() + { + return CreateClassicContext( SerializationCompatibilityLevel.Version0_5 ); + } + + /// + /// Creates a new which is configured as compatible for the specified version. + /// + /// A to specify compatibility level. + /// + /// A new which is configured as compatible for the specified version. + /// /// - /// There are breaking changes of properties to improve API usability and to prevent accidental failure. - /// This method returns a which configured as classic style settings as follows: + /// + /// There are breaking changes of properties to improve API usability and to prevent accidental failure. + /// This method returns a which configured as classic style settings as follows: + /// /// /// /// - /// Default (as of 0.6) - /// Classic (before 0.6) + /// Latest (as of 0.6) + /// Version0_9 (as of 0.6) + /// Version0_5 (formally, "classic", before 0.6) /// /// - /// Packed object members order (if members are not marked with nor System.Runtime.Serialization.DataMemberAttribute and serializer uses ) - /// As declared (metadata table order) - /// As lexicographical - /// - /// - /// value + /// and value + /// value. /// Native representation (100-nano ticks, preserving .) /// UTC, milliseconds Unix epoc. /// + /// + /// Usage of ext types + /// Allowed + /// Allowed + /// Prohibited + /// + /// + /// Binary (such as Byte[]) representation + /// Bin types + /// Bin types + /// Raw types + /// + /// + /// Strings which lengthes are between 17 to 255 + /// Str8 type + /// Str8 types + /// Raw16 type + /// /// + /// + /// In short, prohibits deserialization error in legacy implementation + /// which do not recognize ext types, str8 type, and/or bin types. + /// prohibits only 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. + /// /// - 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." ); + } + } } /// 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/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; + } } /// 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 @@ MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx ..\..\ true - 34322AD6CF171CC843FCCE936CB6B9B616B961E1 + AA68CFB533B03B5B4FAD8AE85A404BD5936CB7C7 8.1 12 @@ -23,7 +23,8 @@ - + + $(DefineConstants);NETFX_CORE;NETSTANDARD1_1;FEATURE_TAP;MSTEST ;2008 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 322dc6f60..9c3c1d013 100644 Binary files a/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx and b/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT_TemporaryKey.pfx differ 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 expected, int arity ) [Test] public void TestEmptyBytes() { - var serializer = this.CreateTarget( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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(); + var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 ); + var serializer = CreateTarget( 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( 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( 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( 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( 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( 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( 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 expected, int arity ) [Test] public void TestEmptyBytes() { - var serializer = this.CreateTarget( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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(); + var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 ); + var serializer = CreateTarget( 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( 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( 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( 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( 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( 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( context ); 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 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs 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 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs 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 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs 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 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs 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..5619c491c 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 @@ {A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx 14.0 - C125CA52683091C62F7746FF9A159E44B2A18673 + 880646284800F8F3356B8C7E3E734562D8BB304F @@ -1551,6 +1551,9 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs 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 bdea5d913..8a0d0bd47 100644 Binary files a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx and b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot_TemporaryKey.pfx differ diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj index 081f56673..58e9423ca 100644 --- a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj +++ b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj @@ -14,11 +14,12 @@ {A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} MsgPack.UnitTest.Uwp_TemporaryKey.pfx 14.0 - 0CEFF2E3DC6DD3A7245B2FB641B6DE056C5A79D9 + 807856C98966D121CA69C33F7D6475CF03AA8633 - + + $(DefineConstants);NETFX_CORE;WINDOWS_UWP;NETSTANDARD1_3;FEATURE_TAP ;2008 false @@ -1533,6 +1534,9 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx index d9a6dd761..604dac0b0 100644 Binary files a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx and b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp_TemporaryKey.pfx differ 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 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj index e0e54b445..856d1dc81 100644 --- a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj +++ b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj @@ -11,7 +11,7 @@ 512 {BC8A1FFA-BEE3-4634-8014-F334798102B3};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} MsgPack.UnitTest.WinRT_TemporaryKey.pfx - A411E1A11B99FF48CFDEDA3098F7F4D0FB6D746D + DEBDFCC31BC8F851996AD84C394EA999CA3ED9D1 8.1 12 @@ -19,7 +19,8 @@ - + + $(DefineConstants);NETFX_CORE;NETSTANDARD1_1;FEATURE_TAP;MSTEST ;2008 @@ -127,6 +128,9 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx index 66ea08c7a..194d5586e 100644 Binary files a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx and b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT_TemporaryKey.pfx differ 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 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs @@ -263,7 +266,7 @@ - + Designer 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 @@ MessagePackExtendedTypeObjectTest.cs + + MessagePackMemberSkipTest.cs + MessagePackObjectDictionaryTest.cs 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 { 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 expected, int arity ) [Test] public void TestEmptyBytes() { - var serializer = this.CreateTarget( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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(); + var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 ); + var serializer = CreateTarget( 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( 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( 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( 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( 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( 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( 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( 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( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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( 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( 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( 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 expected, int arity ) [Test] public void TestEmptyBytes() { - var serializer = this.CreateTarget( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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(); + var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 ); + var serializer = CreateTarget( 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( 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( 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( 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( 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( 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( 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( 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( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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(); + var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 ); + var serializer = CreateTarget( 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( 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( 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( 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( 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( 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( 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 expected, int arity ) [Test] public void TestEmptyBytes() { - var serializer = this.CreateTarget( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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(); + var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 ); + var serializer = CreateTarget( 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( 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( 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( 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( 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( 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( 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( 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( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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( 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( 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( 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 expected, int arity ) [Test] public void TestEmptyBytes() { - var serializer = this.CreateTarget( GetSerializationContext() ); + var context = NewSerializationContext( SerializationCompatibilityLevel.Latest ); + var serializer = this.CreateTarget( 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( 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( 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(); + var context = NewSerializationContext( SerializationCompatibilityLevel.Version0_5 ); + var serializer = CreateTarget( 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( 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( 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( 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( 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( 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( 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; + } + + /// + /// Creates new for generation based testing. + /// + /// . + /// for built-in serializers. + /// A new for generation based testing. + 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>(); + var serializer = context.GetSerializer>(); var dic = new Dictionary { { "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>(); + var serializer = context.GetSerializer>(); var list = new List { "A" }; serializer.Pack( buffer, list ); buffer.Position = 0; @@ -619,7 +682,7 @@ public sealed class NewConcreteCollection : NewAbstractCollection { } - private sealed class StringKeyDictionary : Dictionary + private sealed class StringKeyDictionary : Dictionary { } 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] 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 } } <#+