impl/memory: Fix time serialization encoding.

service/datastore/properties_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 datastore
 
 import (
         "math"
         "testing"
         "time"
@@ skipping 98 matching lines @@
                         })
                         Convey("time gets rounded", func() {
                                 pv := Property{}
                                 now := time.Now().In(time.UTC)
                                 now = now.Round(time.Microsecond).Add(time.Nanosecond * 313)
                                 So(pv.SetValue(now, ShouldIndex), ShouldBeNil)
                                 So(pv.Value(), ShouldHappenBefore, now)
                                 So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTTime")
                         })
+                        Convey("zero time", func() {
+                                now := time.Time{}
+                                So(now.IsZero(), ShouldBeTrue)
+
+                                pv := Property{}
+                                So(pv.SetValue(now, ShouldIndex), ShouldBeNil)
+                                So(pv.Value(), ShouldResemble, now)
+                                v, err := pv.Project(PTInt)
+                                So(err, ShouldBeNil)
+                                So(v, ShouldEqual, 0)
+
+                                So(pv.SetValue(0, ShouldIndex), ShouldBeNil)
+                                So(pv.Value(), ShouldEqual, 0)
+                                v, err = pv.Project(PTTime)
+                                So(err, ShouldBeNil)
+                                So(v.(time.Time).IsZero(), ShouldBeTrue)
+                        })
                         Convey("[]byte allows IndexSetting", func() {
                                 pv := Property{}
                                 So(pv.SetValue([]byte("hello"), ShouldIndex), ShouldBeNil)
                                 So(pv.Value(), ShouldResemble, []byte("hello"))
                                 So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTBytes")
                         })
                 })
+
+                Convey("Comparison", func() {
+                        Convey(`A []byte property should equal a string property with the same value.`, func() {
+                                a := MkProperty([]byte("ohaithere"))
+                                b := MkProperty("ohaithere")
+                                So(a.Equal(&b), ShouldBeTrue)
+                        })
+                })
         })
 }
 
 func TestDSPropertyMapImpl(t *testing.T) {
         t.Parallel()
 
         Convey("PropertyMap load/save err conditions", t, func() {
                 Convey("empty", func() {
                         pm := PropertyMap{}
                         err := pm.Load(PropertyMap{"hello": {Property{}}})
@@ skipping 36 matching lines @@
                         Convey("errors", func() {
 
                                 Convey("weird value", func() {
                                         pm := PropertyMap{}
                                         So(pm.SetMeta("sup", complex(100, 20)), ShouldBeFalse)
                                 })
                         })
                 })
         })
 }