impl/memory: Fix time serialization encoding.

service/datastore/serialize/serialize_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package serialize
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 12 matching lines @@
 }
 
 var (
         mp   = ds.MkProperty
         mpNI = ds.MkPropertyNI
 )
 
 type dspmapTC struct {
         name  string
         props ds.PropertyMap
+        exp   ds.PropertyMap
 }
 
 var mkKey = ds.MakeKey
 
 func mkBuf(data []byte) Buffer {
         return Invertible(bytes.NewBuffer(data))
 }
 
 // TODO(riannucci): dedup with datastore/key testing file
 func ShouldEqualKey(actual interface{}, expected ...interface{}) string {
         if len(expected) != 1 {
                 return fmt.Sprintf("Assertion requires 1 expected value, got %d", len(expected))
         }
         if actual.(*ds.Key).Equal(expected[0].(*ds.Key)) {
                 return ""
         }
         return fmt.Sprintf("Expected: %q\nActual: %q", actual, expected[0])
 }
 
 func TestPropertyMapSerialization(t *testing.T) {
         t.Parallel()
 
+        now := time.Now().UTC()
         tests := []dspmapTC{
                 {
-                        "basic",
-                        ds.PropertyMap{
+                        name: "basic",
+                        props: ds.PropertyMap{
                                 "R": {mp(false), mp(2.1), mpNI(3)},
                                 "S": {mp("hello"), mp("world")},
                         },
                 },
                 {
-                        "keys",
-                        ds.PropertyMap{
+                        name: "keys",
+                        props: ds.PropertyMap{
                                 "DS":        {mp(mkKey("appy", "ns", "Foo", 7)), mp(mkKey("other", "", "Yot", "wheeep"))},
                                 "blobstore": {mp(blobstore.Key("sup")), mp(blobstore.Key("nerds"))},
                         },
                 },
                 {
-                        "geo",
-                        ds.PropertyMap{
+                        name: "geo",
+                        props: ds.PropertyMap{
                                 "G": {mp(ds.GeoPoint{Lat: 1, Lng: 2})},
                         },
                 },
                 {
-                        "data",
-                        ds.PropertyMap{
+                        name: "data",
+                        props: ds.PropertyMap{
                                 "S":          {mp("sup"), mp("fool"), mp("nerd")},
                                 "D.Foo.Nerd": {mp([]byte("sup")), mp([]byte("fool"))},
                         },
                 },
                 {
-                        "time",
-                        ds.PropertyMap{
+                        name: "time",
+                        props: ds.PropertyMap{
                                 "T": {
-                                        mp(time.Now().UTC()),
-                                        mp(time.Now().Add(time.Second).UTC())},
+                                        mp(now),
+                                        mp(now),
+                                },
+                        },
+                        exp: ds.PropertyMap{
+                                "T": {
+                                        mp(timeToInt(now)),
+                                        mp(timeToInt(now)),
+                                },
                         },
                 },
                 {
-                        "empty vals",
-                        ds.PropertyMap{
+                        name: "empty vals",
+                        props: ds.PropertyMap{
                                 "T": {mp(true), mp(true)},
                                 "F": {mp(false), mp(false)},
                                 "N": {mp(nil), mp(nil)},
                                 "E": {},
                         },
                 },
         }
 
         Convey("PropertyMap serialization", t, func() {
                 Convey("round trip", func() {
                         for _, tc := range tests {
                                 tc := tc
                                 Convey(tc.name, func() {
                                         data := ToBytesWithContext(tc.props)
                                         dec, err := ReadPropertyMap(mkBuf(data), WithContext, "", "")
                                         So(err, ShouldBeNil)
-                                        So(dec, ShouldResemble, tc.props)
+
+                                        exp := tc.exp
+                                        if exp == nil {
+                                                exp = tc.props
+                                        }
+                                        So(dec, ShouldResemble, exp)
                                 })
                         }
                 })
         })
 }
 
 func die(err error) {
         if err != nil {
                 panic(err)
         }
@@ skipping 384 matching lines @@
                                                 "__ancestor__": {
                                                         ToBytes(mp(fakeKey)),
                                                         ToBytes(mp(fakeKey.Parent())),
                                                 },
                                         })
                                 })
                         })
                 })
         })
 }