Differentiate between single- and multi- props.

impl/memory/testing_utils_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 memory
 
 import (
         "bytes"
         "fmt"
         "strings"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/luci-go/common/data/cmpbin"
 )
 
 func init() {
         serializationDeterministic = true
         serialize.WritePropertyMapDeterministic = true
 }
 
 var nextMarker = "NEXT MARKER"
 var Next = &nextMarker
 
-// Use like:
+var multiMarker = "MULTI MARKER"
+var Multi = &multiMarker
+
+// If you want an entry that is single to be treated as multi-, prepend it
+// with Multi. Terminate each set of property tokens with Next.
 //   pmap(
 //     "prop", "val", 0, 100, Next,
 //     "other", "val", 0, 100, Next,
+//     "name", Multi, "value", Next,
 //   )
 //
+//
+//
 func pmap(stuff ...interface{}) ds.PropertyMap {
         ret := ds.PropertyMap{}
 
-        nom := func() interface{} {
-                if len(stuff) > 0 {
-                        ret := stuff[0]
-                        stuff = stuff[1:]
-                        return ret
+        nom := func() (name string, toks []interface{}, multi bool) {
+                var i int
+
+                for i = 0; i < len(stuff); i++ {
+                        e := stuff[i]
+                        switch {
+                        case e == Next:
+                                stuff = stuff[i+1:]
+                                return
+                        case e == Multi:
+                                multi = true
+                        case i == 0:
+                                name = e.(string)
+                        default:
+                                toks = append(toks, e)
+                        }
                 }
-                return nil
+
+                stuff = nil
+                return
         }
 
         for len(stuff) > 0 {
-                pname := nom().(string)
+                pname, toks, multi := nom()
+
+                var mp func(interface{}) ds.Property
                 if pname[0] == '$' || (strings.HasPrefix(pname, "__") && strings.HasSuffix(pname, "__")) {
-                        for len(stuff) > 0 && stuff[0] != Next {
-                                ret[pname] = append(ret[pname], propNI(nom()))
+                        mp = propNI
+                } else {
+                        mp = prop
+                }
+
+                if len(toks) == 1 && !multi {
+                        ret[pname] = mp(toks[0])
+                } else {
+                        pslice := make(ds.PropertySlice, len(toks))
+                        for i, tok := range toks {
+                                pslice[i] = mp(tok)
                         }
-                } else {
-                        for len(stuff) > 0 && stuff[0] != Next {
-                                ret[pname] = append(ret[pname], prop(nom()))
-                        }
+                        ret[pname] = pslice
                 }
-                nom()
         }
 
         return ret
 }
 
 func nq(kindMaybe ...string) *ds.Query {
         kind := "Foo"
         if len(kindMaybe) == 1 {
                 kind = kindMaybe[0]
         }
@@ skipping 81 matching lines @@
         ret := cat(bytethings...)
         for i := range ret {
                 ret[i] ^= 0xFF
         }
         return ret
 }
 
 func sat(bytethings ...interface{}) string {
         return string(cat(bytethings...))
 }