Differentiate between single- and multi- props.

impl/memory/race_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 (
         "sync"
         "sync/atomic"
         "testing"
@@ skipping 20 matching lines @@
                         err := ds.RunInTransaction(func(c context.Context) error {
                                 atomic.AddInt32(&num, 1)
 
                                 ds := datastore.Get(c)
 
                                 obj := pmap("$key", ds.MakeKey("Obj", 1))
                                 if err := ds.Get(obj); err != nil && err != datastore.ErrNoSuchEntity {
                                         t.Fatal("error get", err)
                                 }
                                 cur := int64(0)
-                                if ps, ok := obj["Value"]; ok {
+                                if ps := obj.Slice("Value"); len(ps) > 0 {
                                         cur = ps[0].Value().(int64)
                                 }
 
                                 cur++
-                                obj["Value"] = []datastore.Property{prop(cur)}
+                                obj["Value"] = prop(cur)
 
                                 return ds.Put(obj)
                         }, &datastore.TransactionOptions{Attempts: 200})
 
                         if err != nil {
                                 t.Fatal("error during transaction", err)
                         }
 
                         atomic.AddInt32(&value, 1)
                 }()
         }
         wg.Wait()
 
         obj := pmap("$key", ds.MakeKey("Obj", 1))
         if ds.Get(obj) != nil {
                 t.FailNow()
         }
         t.Logf("Ran %d inner functions", num)
-        if int64(value) != obj["Value"][0].Value().(int64) {
-                t.Fatalf("value wrong value %d v %d", value, obj["Value"][0].Value().(int64))
+        if int64(value) != obj.Slice("Value")[0].Value().(int64) {
+                t.Fatalf("value wrong value %d v %d", value, obj.Slice("Value")[0].Value().(int64))
         }
 }
 
 func TestRaceNonConflictingPuts(t *testing.T) {
         t.Parallel()
 
         ds := datastore.Get(Use(context.Background()))
 
         num := int32(0)
 
@@ skipping 15 matching lines @@
                         }
                         atomic.AddInt32(&num, 1)
                 }()
         }
         wg.Wait()
 
         if num != 100 {
                 t.Fatal("expected 100 runs, got", num)
         }
 }