Skip to content

Commit 3e4111d

Browse files
yfakariyayfakariya
committed
Add Timestamp serialization test cases.
1 parent aab77e8 commit 3e4111d

1 file changed

Lines changed: 288 additions & 0 deletions

File tree

‎test/MsgPack.UnitTest/Serialization/TimestampSerializationTest.cs‎

Lines changed: 288 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,288 @@
1+
#region -- License Terms --
2+
//
3+
// MessagePack for CLI
4+
//
5+
// Copyright (C) 2017 FUJIWARA, Yusuke
6+
//
7+
// Licensed under the Apache License, Version 2.0 (the "License");
8+
// you may not use this file except in compliance with the License.
9+
// You may obtain a copy of the License at
10+
//
11+
// http://www.apache.org/licenses/LICENSE-2.0
12+
//
13+
// Unless required by applicable law or agreed to in writing, software
14+
// distributed under the License is distributed on an "AS IS" BASIS,
15+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16+
// See the License for the specific language governing permissions and
17+
// limitations under the License.
18+
//
19+
#endregion -- License Terms --
20+
21+
using System;
22+
using System.IO;
23+
using System.Runtime.InteropServices.ComTypes;
24+
25+
using MsgPack.Serialization.DefaultSerializers;
26+
27+
#if !MSTEST
28+
using NUnit.Framework;
29+
#else
30+
using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
31+
using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
32+
using TimeoutAttribute = NUnit.Framework.TimeoutAttribute;
33+
using Assert = NUnit.Framework.Assert;
34+
using Is = NUnit.Framework.Is;
35+
#endif
36+
37+
namespace MsgPack.Serialization
38+
{
39+
[TestFixture]
40+
public class TimestampSerializationTest
41+
{
42+
private static void TestSerializationCore( SerializationContext context, DateTimeConversionMethod expected )
43+
{
44+
Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( expected ) );
45+
46+
var now = Timestamp.UtcNow;
47+
var dateTimeNow = now.ToDateTimeOffset();
48+
var source =
49+
new ClassHasTimestamp
50+
{
51+
Timestamp = now,
52+
DateTime = dateTimeNow.AddSeconds( 1 ).UtcDateTime,
53+
DateTimeOffset = dateTimeNow.AddSeconds( 2 ),
54+
FileTime = now.Add( TimeSpan.FromSeconds( 3 ) ).ToDateTime().ToWin32FileTimeUtc()
55+
};
56+
57+
using ( var buffer = new MemoryStream() )
58+
{
59+
var serializer = context.GetSerializer<ClassHasTimestamp>();
60+
serializer.Pack(
61+
buffer,
62+
source
63+
);
64+
65+
// Test representation
66+
buffer.Position = 0;
67+
var native = MessagePackSerializer.UnpackMessagePackObject( buffer );
68+
Assert.That( native.IsArray, Is.True );
69+
var nativeMembers = native.AsList();
70+
Assert.That( nativeMembers.Count, Is.EqualTo( ClassHasTimestamp.MemberCount ) );
71+
72+
for ( var i = 0; i < ClassHasTimestamp.MemberCount; i++ )
73+
{
74+
switch ( expected )
75+
{
76+
case DateTimeConversionMethod.Native:
77+
{
78+
if ( i == 2 )
79+
{
80+
// DateTimeOffset -> [long, shourt]
81+
Assert.That( nativeMembers[ i ].IsArray, Is.True );
82+
var dtoComponents = nativeMembers[ i ].AsList();
83+
Assert.That( dtoComponents.Count, Is.EqualTo( 2 ) );
84+
Assert.That( dtoComponents[ 0 ].IsTypeOf<long>(), Is.True );
85+
Assert.That( dtoComponents[ 1 ].IsTypeOf<short>(), Is.True );
86+
}
87+
else
88+
{
89+
Assert.That( nativeMembers[ i ].IsTypeOf<long>(), Is.True );
90+
}
91+
break;
92+
}
93+
case DateTimeConversionMethod.UnixEpoc:
94+
{
95+
Assert.That( nativeMembers[ i ].IsTypeOf<long>(), Is.True );
96+
break;
97+
}
98+
case DateTimeConversionMethod.Timestamp:
99+
{
100+
Assert.That( nativeMembers[ i ].IsTypeOf<MessagePackExtendedTypeObject>(), Is.True );
101+
var asExt = nativeMembers[ i ].AsMessagePackExtendedTypeObject();
102+
Assert.That( asExt.TypeCode, Is.EqualTo( 0xFF ) );
103+
// Actual encoding should be tested in Timestamp tests.
104+
break;
105+
}
106+
}
107+
}
108+
109+
// Test round trip
110+
buffer.Position = 0;
111+
112+
var result = serializer.Unpack( buffer );
113+
switch ( expected )
114+
{
115+
case DateTimeConversionMethod.Native:
116+
{
117+
Assert.That( result.Timestamp, Is.EqualTo( new Timestamp( now.UnixEpochSecondsPart, now.NanosecondsPart / 100 * 100 ) ) );
118+
Assert.That( result.DateTime, Is.EqualTo( now.ToDateTime().AddSeconds( 1 ) ) );
119+
Assert.That( result.DateTimeOffset, Is.EqualTo( now.ToDateTimeOffset().AddSeconds( 2 ) ) );
120+
Assert.That( result.FileTime, Is.EqualTo( now.Add( TimeSpan.FromSeconds( 3 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart % 100 ) ) ).ToDateTime().ToWin32FileTimeUtc() ) );
121+
break;
122+
}
123+
case DateTimeConversionMethod.UnixEpoc:
124+
{
125+
Assert.That( result.Timestamp, Is.EqualTo( new Timestamp( now.UnixEpochSecondsPart, now.NanosecondsPart / 1000000 * 1000000 ) ) );
126+
Assert.That( result.DateTime, Is.EqualTo( now.ToDateTime().AddSeconds( 1 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart / 100 % 10000 ) ) ) );
127+
Assert.That( result.DateTimeOffset, Is.EqualTo( now.ToDateTimeOffset().AddSeconds( 2 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart / 100 % 10000 ) ) ) );
128+
Assert.That( result.FileTime, Is.EqualTo( now.Add( TimeSpan.FromSeconds( 3 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart / 100 % 10000 ) ) ).ToDateTime().ToWin32FileTimeUtc() ) );
129+
break;
130+
}
131+
case DateTimeConversionMethod.Timestamp:
132+
{
133+
Assert.That( result.Timestamp, Is.EqualTo( now ) );
134+
Assert.That( result.DateTime, Is.EqualTo( now.ToDateTime().AddSeconds( 1 ) ) );
135+
Assert.That( result.DateTimeOffset, Is.EqualTo( now.ToDateTimeOffset().AddSeconds( 2 ) ) );
136+
Assert.That( result.FileTime, Is.EqualTo( now.Add( TimeSpan.FromSeconds( 3 ) ).ToDateTime().ToWin32FileTimeUtc() ) );
137+
break;
138+
}
139+
}
140+
}
141+
}
142+
143+
[Test]
144+
public void TestSerialization_DefaultTimestamp()
145+
{
146+
TestSerializationCore( new SerializationContext(), DateTimeConversionMethod.Timestamp );
147+
}
148+
149+
[Test]
150+
public void TestSerialization_ClassicUnixEpoc()
151+
{
152+
TestSerializationCore( SerializationContext.CreateClassicContext(), DateTimeConversionMethod.UnixEpoc );
153+
}
154+
155+
[Test]
156+
public void TestSerialization_Timestamp()
157+
{
158+
TestSerializationCore( new SerializationContext() { DefaultDateTimeConversionMethod = DateTimeConversionMethod.Timestamp }, DateTimeConversionMethod.Timestamp );
159+
}
160+
161+
[Test]
162+
public void TestSerialization_Native()
163+
{
164+
TestSerializationCore( new SerializationContext() { DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native }, DateTimeConversionMethod.Native );
165+
}
166+
167+
[Test]
168+
public void TestSerialization_UnixEpoc()
169+
{
170+
TestSerializationCore( new SerializationContext() { DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc }, DateTimeConversionMethod.UnixEpoc );
171+
}
172+
173+
private static void TestDeserializationCore( DateTimeConversionMethod kind )
174+
{
175+
var now = Timestamp.UtcNow;
176+
var dateTimeNow = now.ToDateTimeOffset();
177+
using ( var buffer = new MemoryStream() )
178+
using ( var packer = Packer.Create( buffer, PackerCompatibilityOptions.None ) )
179+
{
180+
packer.PackArrayHeader( ClassHasTimestamp.MemberCount );
181+
for ( var i = 0; i < ClassHasTimestamp.MemberCount; i++ )
182+
{
183+
switch ( kind )
184+
{
185+
case DateTimeConversionMethod.Native:
186+
{
187+
if ( i == 2 )
188+
{
189+
// DateTimeOffset -> [long, shourt]
190+
packer.PackArrayHeader( 2 );
191+
packer.Pack( dateTimeNow.AddSeconds( i ).Ticks );
192+
packer.Pack( ( short )0 );
193+
}
194+
else
195+
{
196+
packer.Pack( dateTimeNow.AddSeconds( i ).Ticks );
197+
}
198+
199+
break;
200+
}
201+
case DateTimeConversionMethod.UnixEpoc:
202+
{
203+
packer.Pack( MessagePackConvert.FromDateTimeOffset( dateTimeNow.AddSeconds( i ) ) );
204+
break;
205+
}
206+
case DateTimeConversionMethod.Timestamp:
207+
{
208+
packer.PackExtendedTypeValue( ( now.Add( TimeSpan.FromSeconds( i ) ).Encode() ) );
209+
break;
210+
}
211+
default:
212+
{
213+
Assert.Fail( "Unexpected Kind" );
214+
break;
215+
}
216+
}
217+
}
218+
219+
var context = new SerializationContext();
220+
context.DefaultDateTimeConversionMethod = kind;
221+
222+
var serializer = context.GetSerializer<ClassHasTimestamp>();
223+
buffer.Position = 0;
224+
225+
var result = serializer.Unpack( buffer );
226+
switch ( kind )
227+
{
228+
case DateTimeConversionMethod.Native:
229+
{
230+
Assert.That( result.Timestamp, Is.EqualTo( new Timestamp( now.UnixEpochSecondsPart, now.NanosecondsPart / 100 * 100 ) ) );
231+
Assert.That( result.DateTime, Is.EqualTo( now.ToDateTime().AddSeconds( 1 ) ) );
232+
Assert.That( result.DateTimeOffset, Is.EqualTo( now.ToDateTimeOffset().AddSeconds( 2 )) );
233+
Assert.That( result.FileTime, Is.EqualTo( now.Add( TimeSpan.FromSeconds( 3 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart % 100 ) ) ).ToDateTime().ToWin32FileTimeUtc() ) );
234+
break;
235+
}
236+
case DateTimeConversionMethod.UnixEpoc:
237+
{
238+
Assert.That( result.Timestamp, Is.EqualTo( new Timestamp( now.UnixEpochSecondsPart, now.NanosecondsPart / 1000000 * 1000000 ) ) );
239+
Assert.That( result.DateTime, Is.EqualTo( now.ToDateTime().AddSeconds( 1 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart / 100 % 10000 ) ) ) );
240+
Assert.That( result.DateTimeOffset, Is.EqualTo( now.ToDateTimeOffset().AddSeconds( 2 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart / 100 % 10000 ) ) ) );
241+
Assert.That( result.FileTime, Is.EqualTo( now.Add( TimeSpan.FromSeconds( 3 ).Subtract( TimeSpan.FromTicks( now.NanosecondsPart / 100 % 10000 ) ) ).ToDateTime().ToWin32FileTimeUtc() ) );
242+
break;
243+
}
244+
case DateTimeConversionMethod.Timestamp:
245+
{
246+
Assert.That( result.Timestamp, Is.EqualTo( now ) );
247+
Assert.That( result.DateTime, Is.EqualTo( now.ToDateTime().AddSeconds( 1 ) ) );
248+
Assert.That( result.DateTimeOffset, Is.EqualTo( now.ToDateTimeOffset().AddSeconds( 2 ) ) );
249+
Assert.That( result.FileTime, Is.EqualTo( now.Add( TimeSpan.FromSeconds( 3 ) ).ToDateTime().ToWin32FileTimeUtc() ) );
250+
break;
251+
}
252+
}
253+
}
254+
}
255+
256+
[Test]
257+
public void TestDeserialization_FromTimestamp()
258+
{
259+
TestDeserializationCore( DateTimeConversionMethod.Timestamp );
260+
}
261+
262+
[Test]
263+
public void TestDeserialization_FromNative()
264+
{
265+
TestDeserializationCore( DateTimeConversionMethod.Native );
266+
}
267+
268+
[Test]
269+
public void TestDeserialization_FromUnixEpoc()
270+
{
271+
TestDeserializationCore( DateTimeConversionMethod.UnixEpoc );
272+
}
273+
}
274+
275+
public class ClassHasTimestamp
276+
{
277+
internal const int MemberCount = 4;
278+
279+
[MessagePackMember( 0 )]
280+
public Timestamp Timestamp { get; set; }
281+
[MessagePackMember( 1 )]
282+
public DateTime DateTime { get; set; }
283+
[MessagePackMember( 2 )]
284+
public DateTimeOffset DateTimeOffset { get; set; }
285+
[MessagePackMember( 3 )]
286+
public FILETIME FileTime { get; set; }
287+
}
288+
}

0 commit comments

Comments
 (0)