Fix zero time bug

service/datastore/properties.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 datastore
 
 import (
         "encoding/base64"
         "errors"
         "fmt"
@@ skipping 252 matching lines @@
                 err := error(nil)
                 if checkValid && !x.Valid() {
                         err = errors.New("invalid GeoPoint value")
                 }
                 return PTGeoPoint, err
         default:
                 return PTUnknown, fmt.Errorf("gae: Property has bad type %T", v)
         }
 }
 
-// timeLocationsEqual tests if two time.Location are equal.
+// timeLocationIsUTC tests if two time.Location are equal.
 //
 // This is tricky using the standard time API, as time is implicitly normalized
 // to UTC and all equality checks are performed relative to that normalized
 // time. To compensate, we instantiate two new time.Time using the respective
 // Locations.
 func timeLocationIsUTC(l *time.Location) bool {
         return time.Date(1970, 1, 1, 0, 0, 0, 0, l).Equal(utcTestTime)
 }
 
 // UpconvertUnderlyingType takes an object o, and attempts to convert it to
@@ skipping 17 matching lines @@
                 }
         case reflect.Float32, reflect.Float64:
                 o = v.Float()
         case reflect.Slice:
                 if t.Elem().Kind() == reflect.Uint8 {
                         o = v.Bytes()
                 }
         case reflect.Struct:
                 if t == typeOfTime {
                         // time in a Property can only hold microseconds
-                        o = v.Interface().(time.Time).Round(time.Microsecond)
+                        tim := v.Interface().(time.Time)
+                        if !tim.IsZero() {
+                                o = v.Interface().(time.Time).Round(time.Microsecond)
+                        }
                 }
         }
         return o
 }
 
 // Value returns the current value held by this property. It's guaranteed to
 // be a valid value type (i.e. `p.SetValue(p.Value(), true)` will never return
 // an error).
 func (p *Property) Value() interface{} { return p.value }
 
@@ skipping 80 matching lines @@
         case to == p.propType:
                 return p.value, nil
 
         case to == PTInt && p.propType == PTTime:
                 t := p.value.(time.Time)
                 v := uint64(t.Unix())*1e6 + uint64(t.Nanosecond()/1e3)
                 return int64(v), nil
 
         case to == PTTime && p.propType == PTInt:
                 v := p.value.(int64)
-                return time.Unix(int64(v/1e6), int64((v%1e6)*1e3)).UTC(), nil
+                t := time.Unix(int64(v/1e6), int64((v%1e6)*1e3))
+                if t.IsZero() {
+                        return time.Time{}, nil
+                }
+                return t.UTC(), nil
 
         case to == PTString && p.propType == PTBytes:
                 return string(p.value.([]byte)), nil
 
         case to == PTString && p.propType == PTBlobKey:
                 return string(p.value.(blobstore.Key)), nil
 
         case to == PTBytes && p.propType == PTString:
                 return []byte(p.value.(string)), nil
 
@@ skipping 358 matching lines @@
         dflt = UpconvertUnderlyingType(dflt)
         cur, err := gm(key)
         if err != nil {
                 return dflt
         }
         if dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt) {
                 return dflt
         }
         return cur
 }