impl/memory: Fix time serialization encoding.

service/datastore/serialize/serialize.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"
         "errors"
         "fmt"
@@ skipping 171 matching lines @@
 
         gp.Lng, _, e = cmpbin.ReadFloat64(buf)
         panicIf(e)
 
         if !gp.Valid() {
                 err = fmt.Errorf("helper: decoded invalid GeoPoint: %v", gp)
         }
         return
 }
 
+// TimeToInt converts a time value to a datastore-appropraite integer value.
+//
+// This method truncates the time to microseconds and drops the timezone,
+// because that's the (undocumented) way that the appengine SDK does it.
+func TimeToInt(t time.Time) int64 {
+        t = t.Round(time.Microsecond)
+        return t.Unix()*1e6 + int64(t.Nanosecond()/1e3)
+}
+
+// IntToTime converts a time integer produced by TimeToInt to a time.Time
+// instance.
+func IntToTime(v int64) time.Time {
+        t := time.Unix(v/1e6, (v%1e6)*1e3)
+        if t.IsZero() {
+                return time.Time{}
+        }
+        return t.UTC()
+}
+
 // WriteTime writes a time.Time in a byte-sortable way.
 //
-// This method truncates the time to microseconds and drops the timezone,
-// because that's the (undocumented) way that the appengine SDK does it.
+// This method uses TimeToInt to convert the time to an integer value. This
+// truncates the time to microseconds and drops the timezone.
 func WriteTime(buf Buffer, t time.Time) error {
         name, off := t.Zone()
         if name != "UTC" || off != 0 {
                 panic(fmt.Errorf("helper: UTC OR DEATH: %s", t))
         }
-        _, err := cmpbin.WriteInt(buf, t.Unix()*1e6+int64(t.Nanosecond()/1e3))
+        _, err := cmpbin.WriteInt(buf, TimeToInt(t))
         return err
 }
 
 // ReadTime reads a time.Time from the buffer.
 func ReadTime(buf Buffer) (time.Time, error) {
         v, _, err := cmpbin.ReadInt(buf)
         if err != nil {
                 return time.Time{}, err
         }
-        t := time.Unix(v/1e6, (v%1e6)*1e3)
-        if t.IsZero() {
-                return time.Time{}, nil
-        }
-        return t.UTC(), nil
+        return IntToTime(v), nil
 }
 
 // WriteProperty writes a Property to the buffer. `context` behaves the same
 // way that it does for WriteKey, but only has an effect if `p` contains a
 // Key as its Value.
 func WriteProperty(buf Buffer, context KeyContext, p ds.Property) (err error) {
         defer recoverTo(&err)
         typb := byte(p.Type())
         if p.IndexSetting() != ds.NoIndex {
                 typb |= 0x80
@@ skipping 367 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }