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 34 matching lines @@
         }
         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{
                                 "R": {mp(false), mp(2.1), mpNI(3)},
                                 "S": {mp("hello"), mp("world")},
                         },
                 },
                 {
                         "keys",
@@ skipping 12 matching lines @@
                         "data",
                         ds.PropertyMap{
                                 "S":          {mp("sup"), mp("fool"), mp("nerd")},
                                 "D.Foo.Nerd": {mp([]byte("sup")), mp([]byte("fool"))},
                         },
                 },
                 {
                         "time",
                         ds.PropertyMap{
                                 "T": {
-                                        mp(time.Now().UTC()),
-                                        mp(time.Now().Add(time.Second).UTC())},
+                                        mp(now),
+                                        mp(now.Add(time.Second)),
+                                },
                         },
                 },
                 {
                         "empty vals",
                         ds.PropertyMap{
                                 "T": {mp(true), mp(true)},
                                 "F": {mp(false), mp(false)},
                                 "N": {mp(nil), mp(nil)},
                                 "E": {},
                         },
@@ skipping 84 matching lines @@
                 Convey("Time", func() {
                         tp := mp(time.Now().UTC())
                         So(string(ToBytes(tp.Value())), ShouldEqual, string(ToBytes(tp)[1:]))
                 })
 
                 Convey("Zero time", func() {
                         buf := mkBuf(nil)
                         So(WriteTime(buf, time.Time{}), ShouldBeNil)
                         t, err := ReadTime(mkBuf(buf.Bytes()))
                         So(err, ShouldBeNil)
-                        So(t, ShouldResemble, time.Time{})
-                })
-
-                Convey("Bad ToBytes", func() {
-                        So(func() { ToBytes(100.7) }, ShouldPanic)
-                        So(func() { ToBytesWithContext(100.7) }, ShouldPanic)
+                        So(t.Equal(time.Time{}), ShouldBeTrue)
                 })
 
                 Convey("ReadKey", func() {
                         Convey("good cases", func() {
                                 Convey("w/ ctx decodes normally w/ ctx", func() {
                                         k := mkKey("aid", "ns", "knd", "yo", "other", 10)
                                         data := ToBytesWithContext(k)
                                         dk, err := ReadKey(mkBuf(data), WithContext, "", "")
                                         So(err, ShouldBeNil)
                                         So(dk, ShouldEqualKey, k)
@@ skipping 296 matching lines @@
                                                 "__ancestor__": {
                                                         ToBytes(mp(fakeKey)),
                                                         ToBytes(mp(fakeKey.Parent())),
                                                 },
                                         })
                                 })
                         })
                 })
         })
 }