Differentiate between single- and multi- props.

service/datastore/serialize/serialize_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 serialize
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 39 matching lines @@
 }
 
 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")},
+                                "R": ds.PropertySlice{mp(false), mp(2.1), mpNI(3)},
+                                "S": ds.PropertySlice{mp("hello"), mp("world")},
                         },
                 },
                 {
                         "keys",
                         ds.PropertyMap{
-                                "DS": {
+                                "DS": ds.PropertySlice{
                                         mp(mkKey("appy", "ns", "Foo", 7)),
                                         mp(mkKey("other", "", "Yot", "wheeep")),
                                         mp((*ds.Key)(nil)),
                                 },
-                                "blobstore": {mp(blobstore.Key("sup")), mp(blobstore.Key("nerds"))},
+                                "blobstore": ds.PropertySlice{mp(blobstore.Key("sup")), mp(blobstore.Key("nerds"))},
                         },
                 },
                 {
                         "geo",
                         ds.PropertyMap{
-                                "G": {mp(ds.GeoPoint{Lat: 1, Lng: 2})},
+                                "G": mp(ds.GeoPoint{Lat: 1, Lng: 2}),
                         },
                 },
                 {
                         "data",
                         ds.PropertyMap{
-                                "S":          {mp("sup"), mp("fool"), mp("nerd")},
-                                "D.Foo.Nerd": {mp([]byte("sup")), mp([]byte("fool"))},
+                                "S":          ds.PropertySlice{mp("sup"), mp("fool"), mp("nerd")},
+                                "D.Foo.Nerd": ds.PropertySlice{mp([]byte("sup")), mp([]byte("fool"))},
                         },
                 },
                 {
                         "time",
                         ds.PropertyMap{
-                                "T": {
+                                "T": ds.PropertySlice{
                                         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": {},
+                                "T": ds.PropertySlice{mp(true), mp(true)},
+                                "F": ds.PropertySlice{mp(false), mp(false)},
+                                "N": ds.PropertySlice{mp(nil), mp(nil)},
+                                "E": ds.PropertySlice{},
                         },
                 },
         }
 
         Convey("PropertyMap serialization", t, func() {
                 Convey("round trip", func() {
                         for _, tc := range tests {
                                 tc := tc
                                 Convey(tc.name, func() {
                                         data := ToBytesWithContext(tc.props)
@@ skipping 361 matching lines @@
 }
 
 func TestPartialSerialization(t *testing.T) {
         t.Parallel()
 
         fakeKey := mkKey("dev~app", "ns", "parentKind", "sid", "knd", 10)
 
         Convey("TestPartialSerialization", t, func() {
                 Convey("list", func() {
                         pm := ds.PropertyMap{
-                                "wat":  {mpNI("thing"), mp("hat"), mp(100)},
-                                "nerd": {mp(103.7)},
-                                "spaz": {mpNI(false)},
+                                "wat":  ds.PropertySlice{mpNI("thing"), mp("hat"), mp(100)},
+                                "nerd": mp(103.7),
+                                "spaz": mpNI(false),
                         }
                         sip := PropertyMapPartially(fakeKey, pm)
                         So(len(sip), ShouldEqual, 4)
 
                         Convey("single collated", func() {
                                 Convey("indexableMap", func() {
                                         So(sip, ShouldResemble, SerializedPmap{
                                                 "wat": {
                                                         ToBytes(mp("hat")),
                                                         ToBytes(mp(100)),
                                                         // 'thing' is skipped, because it's not NoIndex
                                                 },
                                                 "nerd": {
                                                         ToBytes(mp(103.7)),
                                                 },
                                                 "__key__": {
                                                         ToBytes(mp(fakeKey)),
                                                 },
                                                 "__ancestor__": {
                                                         ToBytes(mp(fakeKey)),
                                                         ToBytes(mp(fakeKey.Parent())),
                                                 },
                                         })
                                 })
                         })
                 })
         })
 }