Differentiate between single- and multi- props.

service/datastore/properties_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package datastore
 
 import (
         "fmt"
         "math"
         "sort"
@@ skipping 176 matching lines @@
                 })
         })
 }
 
 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{}}})
+                        err := pm.Load(PropertyMap{"hello": Property{}})
                         So(err, ShouldBeNil)
-                        So(pm, ShouldResemble, PropertyMap{"hello": {Property{}}})
+                        So(pm, ShouldResemble, PropertyMap{"hello": Property{}})
 
                         npm, _ := pm.Save(false)
                         So(npm, ShouldResemble, pm)
                 })
                 Convey("meta", func() {
                         Convey("working", func() {
-                                pm := PropertyMap{"": {MkProperty("trap!")}}
+                                pm := PropertyMap{"": MkProperty("trap!")}
                                 _, ok := pm.GetMeta("foo")
                                 So(ok, ShouldBeFalse)
 
                                 So(pm.SetMeta("foo", 100), ShouldBeTrue)
 
                                 v, ok := pm.GetMeta("foo")
                                 So(ok, ShouldBeTrue)
                                 So(v, ShouldEqual, 100)
 
                                 So(GetMetaDefault(pm, "foo", 100), ShouldEqual, 100)
 
                                 So(GetMetaDefault(pm, "bar", 100), ShouldEqual, 100)
 
                                 npm, err := pm.Save(false)
                                 So(err, ShouldBeNil)
                                 So(len(npm), ShouldEqual, 0)
                         })
 
                         Convey("too many values picks the first one", func() {
                                 pm := PropertyMap{
-                                        "$thing": {MkProperty(100), MkProperty(200)},
+                                        "$thing": PropertySlice{MkProperty(100), MkProperty(200)},
                                 }
                                 v, ok := pm.GetMeta("thing")
                                 So(ok, ShouldBeTrue)
                                 So(v, ShouldEqual, 100)
                         })
 
                         Convey("errors", func() {
 
                                 Convey("weird value", func() {
                                         pm := PropertyMap{}
@@ skipping 71 matching lines @@
                                                                 cmpBS, _ := c.conv(tc.cmpS)
                                                                 So(cmpByteSequence(bs, cmpBS), tc.assertion, 0)
                                                         })
                                                 }
                                         }
                                 })
                         }
                 }
         })
 }