Use ShouldResemble instead of ShouldResembleV.

service/datastore/datastore_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
@@ skipping 1072 matching lines @@
 
                         Convey("Unless you have an ,extra field!", func() {
                                 type Val struct {
                                         ID int64 `gae:"$id"`
 
                                         Val   int64
                                         Extra PropertyMap `gae:",extra"`
                                 }
                                 tv := &Val{ID: 10}
                                 So(ds.Get(tv), ShouldBeNil)
-                                So(tv, ShouldResembleV, &Val{
+                                So(tv, ShouldResemble, &Val{
                                         ID:  10,
                                         Val: 100,
                                         Extra: PropertyMap{
                                                 "TwoVal": {mp(200)},
                                         },
                                 })
                         })
                 })
 
                 Convey("Can round-trip extra fields", func() {
                         type Expando struct {
                                 ID int64 `gae:"$id"`
 
                                 Something int
                                 Extra     PropertyMap `gae:",extra"`
                         }
                         ex := &Expando{10, 17, PropertyMap{
                                 "Hello": {mp("Hello")},
                                 "World": {mp(true)},
                         }}
                         So(ds.Put(ex), ShouldBeNil)
 
                         ex = &Expando{ID: 10}
                         So(ds.Get(ex), ShouldBeNil)
-                        So(ex, ShouldResembleV, &Expando{
+                        So(ex, ShouldResemble, &Expando{
                                 ID:        10,
                                 Something: 17,
                                 Extra: PropertyMap{
                                         "Hello": {mp("Hello")},
                                         "World": {mp(true)},
                                 },
                         })
                 })
 
                 Convey("Can read-but-not-write", func() {
                         initial := PropertyMap{
                                 "$key":   {mpNI(ds.MakeKey("Convert", 10))},
                                 "Val":    {mp(100)},
                                 "TwoVal": {mp(200)},
                         }
                         So(ds.Put(initial), ShouldBeNil)
                         type Convert struct {
                                 ID int64 `gae:"$id"`
 
                                 Val    int64
                                 NewVal int64
                                 Extra  PropertyMap `gae:"-,extra"`
                         }
                         c := &Convert{ID: 10}
                         So(ds.Get(c), ShouldBeNil)
-                        So(c, ShouldResembleV, &Convert{
+                        So(c, ShouldResemble, &Convert{
                                 ID: 10, Val: 100, NewVal: 0, Extra: PropertyMap{"TwoVal": {mp(200)}},
                         })
                         c.NewVal = c.Extra["TwoVal"][0].Value().(int64)
                         So(ds.Put(c), ShouldBeNil)
 
                         c = &Convert{ID: 10}
                         So(ds.Get(c), ShouldBeNil)
-                        So(c, ShouldResembleV, &Convert{
+                        So(c, ShouldResemble, &Convert{
                                 ID: 10, Val: 100, NewVal: 200, Extra: nil,
                         })
                 })
 
                 Convey("Can black hole", func() {
                         initial := PropertyMap{
                                 "$key":   {mpNI(ds.MakeKey("BlackHole", 10))},
                                 "Val":    {mp(100)},
                                 "TwoVal": {mp(200)},
                         }
@@ skipping 16 matching lines @@
                         }
                         So(ds.Put(initial), ShouldBeNil)
 
                         type IntChange struct {
                                 ID    int64 `gae:"$id"`
                                 Val   string
                                 Extra PropertyMap `gae:"-,extra"`
                         }
                         i := &IntChange{ID: 10}
                         So(ds.Get(i), ShouldBeNil)
-                        So(i, ShouldResembleV, &IntChange{ID: 10, Extra: PropertyMap{"Val": {mp(100)}}})
+                        So(i, ShouldResemble, &IntChange{ID: 10, Extra: PropertyMap{"Val": {mp(100)}}})
                         i.Val = fmt.Sprint(i.Extra["Val"][0].Value())
                         So(ds.Put(i), ShouldBeNil)
 
                         i = &IntChange{ID: 10}
                         So(ds.Get(i), ShouldBeNil)
-                        So(i, ShouldResembleV, &IntChange{ID: 10, Val: "100"})
+                        So(i, ShouldResemble, &IntChange{ID: 10, Val: "100"})
                 })
 
                 Convey("Native fields have priority over Extra fields", func() {
                         type Dup struct {
                                 ID    int64 `gae:"$id"`
                                 Val   int64
                                 Extra PropertyMap `gae:",extra"`
                         }
                         d := &Dup{ID: 10, Val: 100, Extra: PropertyMap{
                                 "Val":   {mp(200)},
                                 "Other": {mp("other")},
                         }}
                         So(ds.Put(d), ShouldBeNil)
 
                         d = &Dup{ID: 10}
                         So(ds.Get(d), ShouldBeNil)
-                        So(d, ShouldResembleV, &Dup{
+                        So(d, ShouldResemble, &Dup{
                                 ID: 10, Val: 100, Extra: PropertyMap{"Other": {mp("other")}},
                         })
                 })
 
                 Convey("Can change repeated field to non-repeating field", func() {
                         initial := PropertyMap{
                                 "$key": {mpNI(ds.MakeKey("NonRepeating", 10))},
                                 "Val":  {mp(100), mp(200), mp(400)},
                         }
                         So(ds.Put(initial), ShouldBeNil)
 
                         type NonRepeating struct {
                                 ID    int64 `gae:"$id"`
                                 Val   int64
                                 Extra PropertyMap `gae:",extra"`
                         }
                         n := &NonRepeating{ID: 10}
                         So(ds.Get(n), ShouldBeNil)
-                        So(n, ShouldResembleV, &NonRepeating{
+                        So(n, ShouldResemble, &NonRepeating{
                                 ID: 10, Val: 0, Extra: PropertyMap{
                                         "Val": {mp(100), mp(200), mp(400)},
                                 },
                         })
                 })
 
                 Convey("Deals correctly with recursive types", func() {
                         initial := PropertyMap{
                                 "$key": {mpNI(ds.MakeKey("Outer", 10))},
                                 "I.A":  {mp(1), mp(2), mp(4)},
                                 "I.B":  {mp(10), mp(20), mp(40)},
                                 "I.C":  {mp(100), mp(200), mp(400)},
                         }
                         So(ds.Put(initial), ShouldBeNil)
                         type Inner struct {
                                 A int64
                                 B int64
                         }
                         type Outer struct {
                                 ID int64 `gae:"$id"`
 
                                 I     []Inner
                                 Extra PropertyMap `gae:",extra"`
                         }
                         o := &Outer{ID: 10}
                         So(ds.Get(o), ShouldBeNil)
-                        So(o, ShouldResembleV, &Outer{
+                        So(o, ShouldResemble, &Outer{
                                 ID: 10,
                                 I: []Inner{
                                         {1, 10},
                                         {2, 20},
                                         {4, 40},
                                 },
                                 Extra: PropertyMap{
                                         "I.C": {mp(100), mp(200), mp(400)},
                                 },
                         })
@@ skipping 97 matching lines @@
                                                 Property:   "business",
                                                 Descending: false,
                                         },
                                         {
                                                 Property:   "owner",
                                                 Descending: false,
                                         },
                                 },
                         },
                 }
-                So(ids, ShouldResembleV, expected)
+                So(ids, ShouldResemble, expected)
         })
 
         Convey("returns non-nil error for incorrectly formatted YAML", t, func() {
 
                 Convey("missing top level `indexes` key", func() {
                         yaml := `
 - kind: Cat
   properties:
   - name: name
   - name: age
@@ skipping 134 matching lines @@
                         if err != nil {
                                 panic(fmt.Errorf("failed to find absolute path for `%s`", sameLevelDir))
                         }
 
                         ids, err := FindAndParseIndexYAML(abs)
                         So(err, ShouldBeNil)
                         So(ids[1].Kind, ShouldEqual, "Test Foo")
                 })
         })
 }