Differentiate between single- and multi- props.

service/datastore/pls_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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
@@ skipping 349 matching lines @@
         return GetPLS(d).Load(props)
 }
 
 func (d *Doubler) Save(withMeta bool) (PropertyMap, error) {
         pls := GetPLS(d)
         propMap, err := pls.Save(withMeta)
         if err != nil {
                 return nil, err
         }
 
+        double := func(prop *Property) {
+                switch v := prop.Value().(type) {
+                case string:
+                        // + means string concatenation.
+                        So(prop.SetValue(v+v, prop.IndexSetting()), ShouldBeNil)
+                case int64:
+                        // + means integer addition.
+                        So(prop.SetValue(v+v, prop.IndexSetting()), ShouldBeNil)
+                }
+        }
+
         // Edit that map and send it on.
-        for _, props := range propMap {
-                for i := range props {
-                        switch v := props[i].Value().(type) {
-                        case string:
-                                // + means string concatenation.
-                                So(props[i].SetValue(v+v, props[i].IndexSetting()), ShouldBeNil)
-                        case int64:
-                                // + means integer addition.
-                                So(props[i].SetValue(v+v, props[i].IndexSetting()), ShouldBeNil)
-                        }
+        for k, v := range propMap {
+                if prop, ok := v.(Property); ok {
+                        double(&prop)
+                        propMap[k] = prop
                 }
         }
         return propMap, nil
 }
 
 func (d *Doubler) Problem() error { return nil }
 
 var _ PropertyLoadSaver = (*Doubler)(nil)
 
 type Deriver struct {
         S, Derived, Ignored string
 }
 
 func (d *Deriver) Load(props PropertyMap) error {
-        for name, p := range props {
+        for name := range props {
                 if name != "S" {
                         continue
                 }
-                d.S = p[0].Value().(string)
+                d.S = props.Slice(name)[0].Value().(string)
                 d.Derived = "derived+" + d.S
         }
         return nil
 }
 
 func (d *Deriver) Save(withMeta bool) (PropertyMap, error) {
-        return map[string][]Property{
-                "S": {mp(d.S)},
+        return map[string]PropertyData{
+                "S": mp(d.S),
         }, nil
 }
 
 func (d *Deriver) Problem() error { return nil }
 
 var _ PropertyLoadSaver = (*Deriver)(nil)
 
 type Augmenter struct {
         S string
 
         g string `gae:"-"`
 }
 
 func (a *Augmenter) Load(props PropertyMap) error {
-        if e := props["Extra"]; len(e) > 0 {
+        if e := props.Slice("Extra"); len(e) > 0 {
                 a.g = e[0].Value().(string)
                 delete(props, "Extra")
         }
         if err := GetPLS(a).Load(props); err != nil {
                 return err
         }
         return nil
 }
 
 func (a *Augmenter) Save(withMeta bool) (PropertyMap, error) {
         props, err := GetPLS(a).Save(withMeta)
         if err != nil {
                 return nil, err
         }
-        props["Extra"] = []Property{MkProperty("ohai!")}
+        props["Extra"] = MkProperty("ohai!")
         return props, nil
 }
 
 func (a *Augmenter) Problem() error { return nil }
 
 var _ PropertyLoadSaver = (*Augmenter)(nil)
 
 type BK struct {
         Key blobstore.Key
 }
@@ skipping 288 matching lines @@
         },
         {
                 desc:    "geopoint invalid",
                 src:     &G0{G: testBadGeoPt},
                 saveErr: "invalid GeoPoint value",
         },
         {
                 desc: "geopoint as props",
                 src:  &G0{G: testGeoPt0},
                 want: PropertyMap{
-                        "G": {mp(testGeoPt0)},
+                        "G": mp(testGeoPt0),
                 },
         },
         {
                 desc: "geopoint slice",
                 src:  &G1{G: []GeoPoint{testGeoPt0, testGeoPt1}},
                 want: &G1{G: []GeoPoint{testGeoPt0, testGeoPt1}},
         },
         {
                 desc: "key",
                 src:  &K0{K: testKey1a},
@@ skipping 33 matching lines @@
         },
         {
                 desc: "time",
                 src:  &T{T: time.Unix(1e9, 0).UTC()},
                 want: &T{T: time.Unix(1e9, 0).UTC()},
         },
         {
                 desc: "time as props",
                 src:  &T{T: time.Unix(1e9, 0).UTC()},
                 want: PropertyMap{
-                        "T": {mp(time.Unix(1e9, 0).UTC())},
+                        "T": mp(time.Unix(1e9, 0).UTC()),
                 },
         },
         {
                 desc: "uint32 save",
                 src:  &U0{U: 1},
                 want: PropertyMap{
-                        "U": {mp(1)},
+                        "U": mp(1),
                 },
         },
         {
                 desc: "uint32 load",
                 src:  &U2{U: 100},
                 want: &U0{U: 100},
         },
         {
                 desc:    "uint32 load oob (neg)",
                 src:     &U2{U: -1},
                 want:    &U0{},
                 loadErr: "overflow",
         },
         {
                 desc:    "uint32 load oob (huge)",
                 src:     &U2{U: math.MaxInt64},
                 want:    &U0{},
                 loadErr: "overflow",
         },
         {
                 desc: "byte save",
                 src:  &U1{U: 1},
                 want: PropertyMap{
-                        "U": {mp(1)},
+                        "U": mp(1),
                 },
         },
         {
                 desc: "byte load",
                 src:  &U2{U: 100},
                 want: &U1{U: 100},
         },
         {
                 desc:    "byte load oob (neg)",
                 src:     &U2{U: -1},
@@ skipping 56 matching lines @@
         },
         {
                 desc: "use convertable slice",
                 src:  &Impossible{[]ImpossibleInner{{Convertable{1, 5, 9}}, {Convertable{2, 4, 6}}}},
                 want: &Impossible{[]ImpossibleInner{{Convertable{1, 5, 9}}, {Convertable{2, 4, 6}}}},
         },
         {
                 desc: "use convertable slice (to map)",
                 src:  &Impossible{[]ImpossibleInner{{Convertable{1, 5, 9}}, {Convertable{2, 4, 6}}}},
                 want: PropertyMap{
-                        "Nested.wot": {mpNI("1,5,9"), mpNI("2,4,6")},
+                        "Nested.wot": PropertySlice{mpNI("1,5,9"), mpNI("2,4,6")},
                 },
         },
         {
                 desc:    "convertable slice (bad load)",
-                src:     PropertyMap{"Nested.wot": {mpNI([]byte("ohai"))}},
+                src:     PropertyMap{"Nested.wot": mpNI([]byte("ohai"))},
                 want:    &Impossible{[]ImpossibleInner{{}}},
                 loadErr: "nope",
         },
         {
                 desc: "use convertable struct",
                 src: &Impossible2{
                         []ImpossibleInner2{
                                 {Convertable2{"nerb", nil}},
                         },
                 },
@@ skipping 23 matching lines @@
         {
                 desc: "convertable json KVMap (to map)",
                 src: &Impossible3{
                         JSONKVProp{
                                 "epic":    "success",
                                 "no_way!": []interface{}{true, "story"},
                                 "what":    []interface{}{"is", "really", 100},
                         },
                 },
                 want: PropertyMap{
-                        "kewelmap": {
-                                mpNI([]byte(
-                                        `{"epic":"success","no_way!":[true,"story"],"what":["is","really",100]}`))},
+                        "kewelmap": mpNI([]byte(
+                                `{"epic":"success","no_way!":[true,"story"],"what":["is","really",100]}`)),
                 },
         },
         {
                 desc: "convertable complex slice",
                 src: &Impossible4{
                         []Complex{complex(1, 2), complex(3, 4)},
                 },
                 want: &Impossible4{
                         []Complex{complex(1, 2), complex(3, 4)},
                 },
         },
         {
                 desc: "convertable complex slice (to map)",
                 src: &Impossible4{
                         []Complex{complex(1, 2), complex(3, 4)},
                 },
                 want: PropertyMap{
-                        "Values": {
-                                mp(GeoPoint{Lat: 1, Lng: 2}), mp(GeoPoint{Lat: 3, Lng: 4})},
+                        "Values": PropertySlice{mp(GeoPoint{Lat: 1, Lng: 2}), mp(GeoPoint{Lat: 3, Lng: 4})},
                 },
         },
         {
                 desc:    "convertable complex slice (bad load)",
-                src:     PropertyMap{"Values": {mp("hello")}},
+                src:     PropertyMap{"Values": mp("hello")},
                 want:    &Impossible4{[]Complex(nil)},
                 loadErr: "nope",
         },
         {
                 desc: "allow concrete *Key implementors (save)",
                 src:  &DerivedKey{testKey2a},
                 want: &IfaceKey{testKey2b},
         },
         {
                 desc: "allow concrete *Key implementors (load)",
@@ skipping 75 matching lines @@
         },
         {
                 desc: "short []byte",
                 src:  &B5{B: makeUint8Slice(3)},
                 want: &B5{B: makeUint8Slice(3)},
         },
         {
                 desc: "short ByteString as props",
                 src:  &B5{B: makeUint8Slice(3)},
                 want: PropertyMap{
-                        "B": {mp(makeUint8Slice(3))},
+                        "B": mp(makeUint8Slice(3)),
                 },
         },
         {
                 desc: "save tagged load props",
                 src:  &Tagged{A: 1, B: []int{21, 22, 23}, C: 3, D: 4, E: 5, I: 6, J: 7},
                 want: PropertyMap{
                         // A and B are renamed to a and b; A and C are noindex, I is ignored.
                         // Indexed properties are loaded before raw properties. Thus, the
                         // result is: b, b, b, D, E, a, c.
-                        "b1": {
+                        "b1": PropertySlice{
                                 mp(21),
                                 mp(22),
                                 mp(23),
                         },
-                        "D": {mp(4)},
-                        "E": {mp(5)},
-                        "a": {mpNI(1)},
-                        "C": {mpNI(3)},
-                        "J": {mpNI(7)},
+                        "D": mp(4),
+                        "E": mp(5),
+                        "a": mpNI(1),
+                        "C": mpNI(3),
+                        "J": mpNI(7),
                 },
         },
         {
                 desc: "save tagged load tagged",
                 src:  &Tagged{A: 1, B: []int{21, 22, 23}, C: 3, D: 4, E: 5, I: 6, J: 7},
                 want: &Tagged{A: 1, B: []int{21, 22, 23}, C: 3, D: 4, E: 5, J: 7},
         },
         {
                 desc: "save props load tagged",
                 src: PropertyMap{
-                        "A": {mpNI(11)},
-                        "a": {mpNI(12)},
+                        "A": mpNI(11),
+                        "a": mpNI(12),
                 },
                 want:    &Tagged{A: 12},
                 loadErr: `cannot load field "A"`,
         },
         {
                 desc:   "invalid tagged1",
                 src:    &InvalidTagged1{I: 1},
                 plsErr: `struct tag has invalid property name: "\t"`,
         },
         {
@@ skipping 19 matching lines @@
         },
         {
                 desc: "doubler",
                 src:  &Doubler{S: "s", I: 1, B: true},
                 want: &Doubler{S: "ss", I: 2, B: true},
         },
         {
                 desc: "save struct load props",
                 src:  &X0{S: "s", I: 1},
                 want: PropertyMap{
-                        "S": {mp("s")},
-                        "I": {mp(1)},
+                        "S": mp("s"),
+                        "I": mp(1),
                 },
         },
         {
                 desc: "save props load struct",
                 src: PropertyMap{
-                        "S": {mp("s")},
-                        "I": {mp(1)},
+                        "S": mp("s"),
+                        "I": mp(1),
                 },
                 want: &X0{S: "s", I: 1},
         },
         {
                 desc: "nil-value props",
                 src: PropertyMap{
-                        "I": {mp(nil)},
-                        "B": {mp(nil)},
-                        "S": {mp(nil)},
-                        "F": {mp(nil)},
-                        "K": {mp(nil)},
-                        "T": {mp(nil)},
-                        "J": {
+                        "I": mp(nil),
+                        "B": mp(nil),
+                        "S": mp(nil),
+                        "F": mp(nil),
+                        "K": mp(nil),
+                        "T": mp(nil),
+                        "J": PropertySlice{
                                 mp(nil),
                                 mp(7),
                                 mp(nil),
                         },
                 },
                 want: &struct {
                         I int64
                         B bool
                         S string
                         F float64
@@ skipping 14 matching lines @@
                                 {30, "thirty"},
                         },
                         J: Inner2{
                                 Y: 3.14,
                         },
                         Inner3: Inner3{
                                 Z: true,
                         },
                 },
                 want: PropertyMap{
-                        "A": {mp(1)},
-                        "I.W": {
+                        "A": mp(1),
+                        "I.W": PropertySlice{
                                 mp(10),
                                 mp(20),
                                 mp(30),
                         },
-                        "I.X": {
+                        "I.X": PropertySlice{
                                 mp("ten"),
                                 mp("twenty"),
                                 mp("thirty"),
                         },
-                        "J.Y": {mp(3.14)},
-                        "Z":   {mp(true)},
+                        "J.Y": mp(3.14),
+                        "Z":   mp(true),
                 },
         },
         {
                 desc: "save props load outer-equivalent",
                 src: PropertyMap{
-                        "A": {mp(1)},
-                        "I.W": {
+                        "A": mp(1),
+                        "I.W": PropertySlice{
                                 mp(10),
                                 mp(20),
                                 mp(30),
                         },
-                        "I.X": {
+                        "I.X": PropertySlice{
                                 mp("ten"),
                                 mp("twenty"),
                                 mp("thirty"),
                         },
-                        "J.Y": {mp(3.14)},
-                        "Z":   {mp(true)},
+                        "J.Y": mp(3.14),
+                        "Z":   mp(true),
                 },
                 want: &OuterEquivalent{
                         A:     1,
                         IDotW: []int32{10, 20, 30},
                         IDotX: []string{"ten", "twenty", "thirty"},
                         JDotY: 3.14,
                         Z:     true,
                 },
         },
         {
@@ skipping 17 matching lines @@
                         },
                         Inner3: Inner3{
                                 Z: true,
                         },
                 },
         },
         {
                 desc: "dotted names save",
                 src:  &Dotted{A: DottedA{B: DottedB{C: 88}}},
                 want: PropertyMap{
-                        "A0.A1.A2.B3.C4.C5": {mp(88)},
+                        "A0.A1.A2.B3.C4.C5": mp(88),
                 },
         },
         {
                 desc: "dotted names load",
                 src: PropertyMap{
-                        "A0.A1.A2.B3.C4.C5": {mp(99)},
+                        "A0.A1.A2.B3.C4.C5": mp(99),
                 },
                 want: &Dotted{A: DottedA{B: DottedB{C: 99}}},
         },
         {
                 desc: "save struct load deriver",
                 src:  &X0{S: "s", I: 1},
                 want: &Deriver{S: "s", Derived: "derived+s"},
         },
         {
                 desc: "save deriver load struct",
                 src:  &Deriver{S: "s", Derived: "derived+s", Ignored: "ignored"},
                 want: &X0{S: "s"},
         },
         {
                 desc: "augmenter save",
                 src:  &Augmenter{S: "s"},
                 want: PropertyMap{
-                        "S":     {mp("s")},
-                        "Extra": {mp("ohai!")},
+                        "S":     mp("s"),
+                        "Extra": mp("ohai!"),
                 },
         },
         {
                 desc: "augmenter load",
                 src: PropertyMap{
-                        "S":     {mp("s")},
-                        "Extra": {mp("kthxbye!")},
+                        "S":     mp("s"),
+                        "Extra": mp("kthxbye!"),
                 },
                 want: &Augmenter{S: "s", g: "kthxbye!"},
         },
         // Regression: CL 25062824 broke handling of appengine.BlobKey fields.
         {
                 desc: "appengine.BlobKey",
                 src:  &BK{Key: "blah"},
                 want: &BK{Key: "blah"},
         },
         {
@@ skipping 42 matching lines @@
                 src: &ExoticTypes{
                         BS: "sup",
                 },
                 want: &ExoticTypes{
                         BS: "sup",
                 },
         },
         {
                 desc: "exotic type projection",
                 src: PropertyMap{
-                        "BS": {mp([]byte("I'mABlobKey"))},
+                        "BS": mp([]byte("I'mABlobKey")),
                 },
                 want: &ExoticTypes{
                         BS: "I'mABlobKey",
                 },
         },
         {
                 desc:   "underspecified types",
                 src:    &Underspecified{},
                 plsErr: "non-concrete interface",
         },
         {
                 desc: "mismatch (string)",
                 src: PropertyMap{
-                        "K": {mp(199)},
-                        "S": {mp([]byte("cats"))},
-                        "F": {mp("nurbs")},
+                        "K": mp(199),
+                        "S": mp([]byte("cats")),
+                        "F": mp("nurbs"),
                 },
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (float)",
-                src:     PropertyMap{"F": {mp(blobstore.Key("wot"))}},
+                src:     PropertyMap{"F": mp(blobstore.Key("wot"))},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (float/overflow)",
-                src:     PropertyMap{"F": {mp(math.MaxFloat64)}},
+                src:     PropertyMap{"F": mp(math.MaxFloat64)},
                 want:    &MismatchTypes{},
                 loadErr: "overflows",
         },
         {
                 desc:    "mismatch (key)",
-                src:     PropertyMap{"K": {mp(false)}},
+                src:     PropertyMap{"K": mp(false)},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (bool)",
-                src:     PropertyMap{"B": {mp(testKey0)}},
+                src:     PropertyMap{"B": mp(testKey0)},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (time)",
-                src:     PropertyMap{"T": {mp(GeoPoint{})}},
+                src:     PropertyMap{"T": mp(GeoPoint{})},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (geopoint)",
-                src:     PropertyMap{"G": {mp(time.Now().UTC())}},
+                src:     PropertyMap{"G": mp(time.Now().UTC())},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc: "slice of structs",
                 src: &N1{
                         X0: X0{S: "one", I: 2, i: 3},
                         Nonymous: []X0{
                                 {S: "four", I: 5, i: 6},
                                 {S: "seven", I: 8, i: 9},
@@ skipping 91 matching lines @@
                                 X0: X0{S: "bleu"},
                                 Nonymous: []X0{
                                         {S: "blu0"},
                                         {S: "blu1"},
                                         {S: "blu2"},
                                         {S: "blu3"},
                                 },
                         },
                 },
                 want: PropertyMap{
-                        "red.S":            {mp("rouge")},
-                        "red.I":            {mp(0)},
-                        "red.Nonymous.S":   {mp("rosso0"), mp("rosso1")},
-                        "red.Nonymous.I":   {mp(0), mp(0)},
-                        "red.Other":        {mp("")},
-                        "green.S":          {mp("vert")},
-                        "green.I":          {mp(0)},
-                        "green.Nonymous.S": {mp("verde0"), mp("verde1"), mp("verde2")},
-                        "green.Nonymous.I": {mp(0), mp(0), mp(0)},
-                        "green.Other":      {mp("")},
-                        "Blue.S":           {mp("bleu")},
-                        "Blue.I":           {mp(0)},
-                        "Blue.Nonymous.S":  {mp("blu0"), mp("blu1"), mp("blu2"), mp("blu3")},
-                        "Blue.Nonymous.I":  {mp(0), mp(0), mp(0), mp(0)},
-                        "Blue.Other":       {mp("")},
+                        "red.S":            mp("rouge"),
+                        "red.I":            mp(0),
+                        "red.Nonymous.S":   PropertySlice{mp("rosso0"), mp("rosso1")},
+                        "red.Nonymous.I":   PropertySlice{mp(0), mp(0)},
+                        "red.Other":        mp(""),
+                        "green.S":          mp("vert"),
+                        "green.I":          mp(0),
+                        "green.Nonymous.S": PropertySlice{mp("verde0"), mp("verde1"), mp("verde2")},
+                        "green.Nonymous.I": PropertySlice{mp(0), mp(0), mp(0)},
+                        "green.Other":      mp(""),
+                        "Blue.S":           mp("bleu"),
+                        "Blue.I":           mp(0),
+                        "Blue.Nonymous.S":  PropertySlice{mp("blu0"), mp("blu1"), mp("blu2"), mp("blu3")},
+                        "Blue.Nonymous.I":  PropertySlice{mp(0), mp(0), mp(0), mp(0)},
+                        "Blue.Other":       mp(""),
                 },
         },
         {
                 desc: "save props load structs with ragged fields",
                 src: PropertyMap{
-                        "red.S":            {mp("rot")},
-                        "green.Nonymous.I": {mp(10), mp(11), mp(12), mp(13)},
-                        "Blue.Nonymous.S":  {mp("blau0"), mp("blau1"), mp("blau2")},
-                        "Blue.Nonymous.I":  {mp(20), mp(21)},
+                        "red.S":            mp("rot"),
+                        "green.Nonymous.I": PropertySlice{mp(10), mp(11), mp(12), mp(13)},
+                        "Blue.Nonymous.S":  PropertySlice{mp("blau0"), mp("blau1"), mp("blau2")},
+                        "Blue.Nonymous.I":  PropertySlice{mp(20), mp(21)},
                 },
                 want: &N2{
                         N1: N1{
                                 X0: X0{S: "rot"},
                         },
                         Green: N1{
                                 Nonymous: []X0{
                                         {I: 10},
                                         {I: 11},
                                         {I: 12},
@@ skipping 15 matching lines @@
                         A struct {
                                 X string `gae:",noindex"`
                                 Y string
                         } `gae:",noindex"`
                         B struct {
                                 X string `gae:",noindex"`
                                 Y string
                         }
                 }{},
                 want: PropertyMap{
-                        "B.Y": {mp("")},
-                        "A.X": {mpNI("")},
-                        "A.Y": {mpNI("")},
-                        "B.X": {mpNI("")},
+                        "B.Y": mp(""),
+                        "A.X": mpNI(""),
+                        "A.Y": mpNI(""),
+                        "B.X": mpNI(""),
                 },
         },
         {
                 desc: "embedded struct with name override",
                 src: &struct {
                         Inner1 `gae:"foo"`
                 }{},
                 want: PropertyMap{
-                        "foo.W": {mp(0)},
-                        "foo.X": {mp("")},
+                        "foo.W": mp(0),
+                        "foo.X": mp(""),
                 },
         },
         {
                 desc:   "slice of slices",
                 src:    &SliceOfSlices{},
                 plsErr: `flattening nested structs leads to a slice of slices: field "S"`,
         },
         {
                 desc:   "recursive struct",
                 src:    &Recursive{},
                 plsErr: `field "R" is recursively defined`,
         },
         {
                 desc:   "mutually recursive struct",
                 src:    &MutuallyRecursive0{},
                 plsErr: `field "R" has problem: field "R" is recursively defined`,
         },
         {
                 desc: "non-exported struct fields",
                 src: &struct {
                         i, J int64
                 }{i: 1, J: 2},
                 want: PropertyMap{
-                        "J": {mp(2)},
+                        "J": mp(2),
                 },
         },
         {
                 desc: "json.RawMessage",
                 src: &struct {
                         J json.RawMessage
                 }{
                         J: json.RawMessage("rawr"),
                 },
                 want: PropertyMap{
-                        "J": {mp([]byte("rawr"))},
+                        "J": mp([]byte("rawr")),
                 },
         },
         {
                 desc: "json.RawMessage to myBlob",
                 src: &struct {
                         B json.RawMessage
                 }{
                         B: json.RawMessage("rawr"),
                 },
                 want: &B2{B: myBlob("rawr")},
@@ skipping 26 matching lines @@
                                                 return
                                         }
                                 }
                                 So(pls, ShouldNotBeNil)
 
                                 savedProps, err := pls.Save(false)
                                 if tc.saveErr != "" {
                                         So(err, ShouldErrLike, tc.saveErr)
                                         return
                                 }
+                                So(err, ShouldBeNil)
                                 So(savedProps, ShouldNotBeNil)
 
                                 var got interface{}
                                 if _, ok := tc.want.(PropertyMap); ok {
                                         pls = PropertyMap{}
                                         got = pls
                                 } else {
                                         got = reflect.New(reflect.TypeOf(tc.want).Elem()).Interface()
                                         if pls, ok = got.(PropertyLoadSaver); !ok {
                                                 var err error
@@ skipping 94 matching lines @@
                         So(o.ID, ShouldEqual, 20)
 
                         So(mgs.SetMeta("id", math.MaxUint32), ShouldBeTrue)
                         So(o.ID, ShouldEqual, math.MaxUint32)
                 })
         })
 
         Convey("StructPLS Miscellaneous", t, func() {
                 Convey("a simple struct has a default $kind", func() {
                         So(GetPLS(&Simple{}).GetAllMeta(), ShouldResemble, PropertyMap{
-                                "$kind": []Property{mpNI("Simple")},
+                                "$kind": mpNI("Simple"),
                         })
                 })
 
                 Convey("multiple overlapping fields is an error", func() {
                         o := &BadMeta{}
                         So(func() { GetPLS(o) }, ShouldPanicLike, "multiple times")
                 })
 
                 Convey("empty property names are invalid", func() {
                         So(validPropertyName(""), ShouldBeFalse)
@@ skipping 55 matching lines @@
 
                 Convey("meta fields can be saved", func() {
                         type OKDefaults struct {
                                 When   string `gae:"$when,tomorrow"`
                                 Amount int64  `gae:"$amt,100"`
                         }
                         pls := GetPLS(&OKDefaults{})
                         pm, err := pls.Save(true)
                         So(err, ShouldBeNil)
                         So(pm, ShouldResemble, PropertyMap{
-                                "$when": {mpNI("tomorrow")},
-                                "$amt":  {mpNI(100)},
-                                "$kind": {mpNI("OKDefaults")},
+                                "$when": mpNI("tomorrow"),
+                                "$amt":  mpNI(100),
+                                "$kind": mpNI("OKDefaults"),
                         })
 
                         v, ok := pm.GetMeta("when")
                         So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, "tomorrow")
 
                         v, ok = pm.GetMeta("amt")
                         So(ok, ShouldBeTrue)
                         So(v, ShouldEqual, int64(100))
                 })
@@ skipping 85 matching lines @@
 
                         So(GetMetaDefault(mgs, "kind", ""), ShouldEqual, "CoolKind")
 
                         So(mgs.SetMeta("kind", "Something"), ShouldBeFalse)
                         So(mgs.SetMeta("id", "happy|27"), ShouldBeTrue)
 
                         So(idp.parent, ShouldEqual, "happy")
                         So(idp.id, ShouldEqual, 27)
 
                         So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
-                                "$id":   {mpNI("happy|27")},
-                                "$kind": {mpNI("CoolKind")},
+                                "$id":   mpNI("happy|27"),
+                                "$kind": mpNI("CoolKind"),
                         })
                 })
 
                 Convey("MetaGetterSetter implementation (KindOverride)", func() {
                         ko := &KindOverride{ID: 20}
                         mgs := getMGS(ko)
                         So(GetMetaDefault(mgs, "kind", ""), ShouldEqual, "KindOverride")
 
                         ko.customKind = "something"
                         So(GetMetaDefault(mgs, "kind", ""), ShouldEqual, "something")
 
                         So(mgs.SetMeta("kind", "Nerp"), ShouldBeTrue)
                         So(ko.customKind, ShouldEqual, "Nerp")
 
                         So(mgs.SetMeta("kind", "KindOverride"), ShouldBeTrue)
                         So(ko.customKind, ShouldEqual, "")
 
                         So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
-                                "$id":   {mpNI(20)},
-                                "$kind": {mpNI("KindOverride")},
+                                "$id":   mpNI(20),
+                                "$kind": mpNI("KindOverride"),
                         })
                         ko.customKind = "wut"
                         So(mgs.GetAllMeta(), ShouldResemble, PropertyMap{
-                                "$id":   {mpNI(20)},
-                                "$kind": {mpNI("wut")},
+                                "$id":   mpNI(20),
+                                "$kind": mpNI("wut"),
                         })
 
                         props, err := GetPLS(ko).Save(true)
                         So(err, ShouldBeNil)
                         So(props, ShouldResemble, PropertyMap{
-                                "$id":   {mpNI(20)},
-                                "$kind": {mpNI("wut")},
+                                "$id":   mpNI(20),
+                                "$kind": mpNI("wut"),
                         })
                 })
 
                 Convey("Embeddable Metadata structs", func() {
                         ide := &IDEmbedder{EmbeddedID{"hello", 10}}
                         pls := GetPLS(ide)
                         val, ok := pls.GetMeta("id")
                         So(ok, ShouldBeTrue)
                         So(val, ShouldEqual, "hello|10")
 
                         So(pls.SetMeta("id", "sup|1337"), ShouldBeTrue)
                         So(ide.EmbeddedID, ShouldResemble, EmbeddedID{"sup", 1337})
 
                         So(pls.GetAllMeta(), ShouldResemble, PropertyMap{
-                                "$id":   {mpNI("sup|1337")},
-                                "$kind": {mpNI("IDEmbedder")},
+                                "$id":   mpNI("sup|1337"),
+                                "$kind": mpNI("IDEmbedder"),
                         })
                 })
         })
 }