equality_test.go

package assertions

import (
	"fmt"
	"reflect"
	"time"
)

func (this *AssertionsFixture) TestShouldEqual() {
	this.fail(so(1, ShouldEqual), "This assertion requires exactly 1 comparison values (you provided 0).")
	this.fail(so(1, ShouldEqual, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).")
	this.fail(so(1, ShouldEqual, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")

	this.pass(so(1, ShouldEqual, 1))
	this.fail(so(1, ShouldEqual, 2), "2|1|Expected: 2 Actual: 1 (Should equal)!")
	this.fail(so(1, ShouldEqual, "1"), `1|1|Expected: "1" Actual: 1 (Should equal)!`)

	this.pass(so(nil, ShouldEqual, nil))

	this.pass(so(true, ShouldEqual, true))
	this.fail(so(true, ShouldEqual, false), "false|true|Expected: false Actual: true (Should equal)!")

	this.pass(so("hi", ShouldEqual, "hi"))
	this.fail(so("hi", ShouldEqual, "bye"), `bye|hi|Expected: "bye" Actual: "hi" (Should equal)!`)

	this.pass(so(42, ShouldEqual, uint(42)))

	this.fail(so(Thing1{"hi"}, ShouldEqual, Thing1{}), `{}|{hi}|Expected: assertions.Thing1{a:""} Actual: assertions.Thing1{a:"hi"} (Should equal)! Diff: 'assertions.Thing1{a:"hi"}'`)
	this.pass(so(Thing1{"hi"}, ShouldEqual, Thing1{"hi"}))
	this.pass(so(&Thing1{"hi"}, ShouldEqual, &Thing1{"hi"}))

	this.fail(so(Thing1{}, ShouldEqual, Thing2{}), `{}|{}|Expected: assertions.Thing2{a:""} Actual: assertions.Thing1{a:""} (Should equal)! Diff: 'assertions.Thing21{a:""}'`)

	this.pass(so(ThingWithEqualMethod{"hi"}, ShouldEqual, ThingWithEqualMethod{"hi"}))
	this.fail(so(ThingWithEqualMethod{"hi"}, ShouldEqual, ThingWithEqualMethod{"bye"}),
		`{bye}|{hi}|Expected: assertions.ThingWithEqualMethod{a:"bye"} Actual: assertions.ThingWithEqualMethod{a:"hi"} (Should equal)! Diff: 'assertions.ThingWithEqualMethod{a:"byehi"}'`)
}
func (this *AssertionsFixture) TestShouldEqual_Issue53() {
	a := func() {}
	b := a
	this.pass(so(a, ShouldEqual, b))
	this.fail(so(a, ShouldEqual, func() {}), "[no-check]")
}
func (this *AssertionsFixture) TestShouldEqual_Issue22_GoConveyIssue437() {
	// https://github.com/smartystreets/goconvey/issues/437#issue-166724312
	type A struct {
		UID      string
		CID      string
		Metadata map[string]any
	}
	this.pass(so(
		A{UID: "joe", CID: "cid", Metadata: map[string]any{"key": "value string", "key int": 3, "key array": []any{2, "blabla"}}}, ShouldEqual,
		A{UID: "joe", CID: "cid", Metadata: map[string]any{"key": "value string", "key int": 3, "key array": []any{2, "blabla"}}}))

	// https://github.com/smartystreets/goconvey/issues/437#issuecomment-258787465
	this.pass(so(
		map[string]any{"basecost": 12000, "basemin": 60, "initialcost": 0, "initialmin": 0, "overtimecost": 0, "overtimemin": 0}, ShouldEqual,
		map[string]any{"basecost": 12000, "basemin": 60, "initialcost": 0, "initialmin": 0, "overtimecost": 0, "overtimemin": 0}))

	// https://github.com/smartystreets/goconvey/issues/437#issuecomment-263060222
	this.pass(so(
		map[string]any{"fields": []string{}, "limit": 25, "offset": 0}, ShouldEqual,
		map[string]any{"fields": []string{}, "limit": 25, "offset": 0}))
}
func (this *AssertionsFixture) TestShouldEqual_TimeValues() {
	var (
		gopherCon, _ = time.LoadLocation("America/Denver")
		elsewhere, _ = time.LoadLocation("America/New_York")

		timeNow          = time.Now().In(gopherCon)
		timeNowElsewhere = timeNow.In(elsewhere)
		timeLater        = timeNow.Add(time.Nanosecond)
	)

	this.pass(so(timeNow, ShouldEqual, timeNowElsewhere)) // Time.Equal method used to determine exact instant.
	this.pass(so(timeNow, ShouldNotEqual, timeLater))
}

func (this *AssertionsFixture) TestShouldNotEqual() {
	this.fail(so(1, ShouldNotEqual), "This assertion requires exactly 1 comparison values (you provided 0).")
	this.fail(so(1, ShouldNotEqual, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).")
	this.fail(so(1, ShouldNotEqual, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")

	this.pass(so(1, ShouldNotEqual, 2))
	this.pass(so(1, ShouldNotEqual, "1"))
	this.fail(so(1, ShouldNotEqual, 1), "Expected '1' to NOT equal '1' (but it did)!")

	this.pass(so(true, ShouldNotEqual, false))
	this.fail(so(true, ShouldNotEqual, true), "Expected 'true' to NOT equal 'true' (but it did)!")

	this.pass(so("hi", ShouldNotEqual, "bye"))
	this.fail(so("hi", ShouldNotEqual, "hi"), "Expected 'hi' to NOT equal 'hi' (but it did)!")

	this.fail(so(&Thing1{"hi"}, ShouldNotEqual, &Thing1{"hi"}), "Expected '&{hi}' to NOT equal '&{hi}' (but it did)!")
	this.fail(so(Thing1{"hi"}, ShouldNotEqual, Thing1{"hi"}), "Expected '{hi}' to NOT equal '{hi}' (but it did)!")
	this.fail(so(Thing1{}, ShouldNotEqual, Thing1{}), "Expected '{}' to NOT equal '{}' (but it did)!")
	this.pass(so(Thing1{}, ShouldNotEqual, Thing2{}))
}

func (this *AssertionsFixture) TestShouldAlmostEqual() {
	this.fail(so(1, ShouldAlmostEqual), "This assertion requires exactly one comparison value and an optional delta (you provided neither)")
	this.fail(so(1, ShouldAlmostEqual, 1, 2, 3), "This assertion requires exactly one comparison value and an optional delta (you provided more values)")
	this.fail(so(1, ShouldAlmostEqual, "1"), "The comparison value must be a numerical type, but was: string")
	this.fail(so(1, ShouldAlmostEqual, 1, "1"), "The delta value must be a numerical type, but was: string")
	this.fail(so("1", ShouldAlmostEqual, 1), "The actual value must be a numerical type, but was: string")

	// with the default delta
	this.pass(so(0.99999999999999, ShouldAlmostEqual, uint(1)))
	this.pass(so(1, ShouldAlmostEqual, 0.99999999999999))
	this.pass(so(1.3612499999999996, ShouldAlmostEqual, 1.36125))
	this.pass(so(0.7285312499999999, ShouldAlmostEqual, 0.72853125))
	this.fail(so(1, ShouldAlmostEqual, .99), "Expected '1' to almost equal '0.99' (but it didn't)!")

	// with a different delta
	this.pass(so(100.0, ShouldAlmostEqual, 110.0, 10.0))
	this.fail(so(100.0, ShouldAlmostEqual, 111.0, 10.5), "Expected '100' to almost equal '111' (but it didn't)!")

	// various ints should work
	this.pass(so(100, ShouldAlmostEqual, 100.0))
	this.pass(so(int(100), ShouldAlmostEqual, 100.0))
	this.pass(so(int8(100), ShouldAlmostEqual, 100.0))
	this.pass(so(int16(100), ShouldAlmostEqual, 100.0))
	this.pass(so(int32(100), ShouldAlmostEqual, 100.0))
	this.pass(so(int64(100), ShouldAlmostEqual, 100.0))
	this.pass(so(uint(100), ShouldAlmostEqual, 100.0))
	this.pass(so(uint8(100), ShouldAlmostEqual, 100.0))
	this.pass(so(uint16(100), ShouldAlmostEqual, 100.0))
	this.pass(so(uint32(100), ShouldAlmostEqual, 100.0))
	this.pass(so(uint64(100), ShouldAlmostEqual, 100.0))
	this.pass(so(100, ShouldAlmostEqual, 100.0))
	this.fail(so(100, ShouldAlmostEqual, 99.0), "Expected '100' to almost equal '99' (but it didn't)!")

	// floats should work
	this.pass(so(float64(100.0), ShouldAlmostEqual, float32(100.0)))
	this.fail(so(float32(100.0), ShouldAlmostEqual, 99.0, float32(0.1)), "Expected '100' to almost equal '99' (but it didn't)!")
}

func (this *AssertionsFixture) TestShouldNotAlmostEqual() {
	this.fail(so(1, ShouldNotAlmostEqual), "This assertion requires exactly one comparison value and an optional delta (you provided neither)")
	this.fail(so(1, ShouldNotAlmostEqual, 1, 2, 3), "This assertion requires exactly one comparison value and an optional delta (you provided more values)")

	// with the default delta
	this.fail(so(1, ShouldNotAlmostEqual, .99999999999999), "Expected '1' to NOT almost equal '0.99999999999999' (but it did)!")
	this.fail(so(1.3612499999999996, ShouldNotAlmostEqual, 1.36125), "Expected '1.3612499999999996' to NOT almost equal '1.36125' (but it did)!")
	this.pass(so(1, ShouldNotAlmostEqual, .99))

	// with a different delta
	this.fail(so(100.0, ShouldNotAlmostEqual, 110.0, 10.0), "Expected '100' to NOT almost equal '110' (but it did)!")
	this.pass(so(100.0, ShouldNotAlmostEqual, 111.0, 10.5))

	// ints should work
	this.fail(so(100, ShouldNotAlmostEqual, 100.0), "Expected '100' to NOT almost equal '100' (but it did)!")
	this.pass(so(100, ShouldNotAlmostEqual, 99.0))

	// float32 should work
	this.fail(so(float64(100.0), ShouldNotAlmostEqual, float32(100.0)), "Expected '100' to NOT almost equal '100' (but it did)!")
	this.pass(so(float32(100.0), ShouldNotAlmostEqual, 99.0, float32(0.1)))
}

func (this *AssertionsFixture) TestShouldResemble() {
	this.fail(so(Thing1{"hi"}, ShouldResemble), "This assertion requires exactly 1 comparison values (you provided 0).")
	this.fail(so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).")

	this.pass(so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"}))
	this.fail(so(Thing1{"hi"}, ShouldResemble, Thing1{"bye"}), `{bye}|{hi}|Expected: assertions.Thing1{a:"bye"} Actual: assertions.Thing1{a:"hi"} (Should equal)! Diff: 'assertions.Thing1{a:"byehi"}'`)

	var (
		a []int
		b []int = []int{}
	)

	this.fail(so(a, ShouldResemble, b), `[]|[]|Expected: []int{} Actual: []int(nil) (Should equal)!`)
	this.fail(so(2, ShouldResemble, 1), `1|2|Expected: 1 Actual: 2 (Should equal)!`)

	this.fail(so(StringStringMapAlias{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"}),
		`map[hi:bye]|map[hi:bye]|Expected: map[string]string{"hi":"bye"} Actual: assertions.StringStringMapAlias{"hi":"bye"} (Should equal)! Diff: 'map[ssertions.String]sStringMapAlias{"hi":"bye"}'`)
	this.fail(so(StringSliceAlias{"hi", "bye"}, ShouldResemble, []string{"hi", "bye"}),
		`[hi bye]|[hi bye]|Expected: []string{"hi", "bye"} Actual: assertions.StringSliceAlias{"hi", "bye"} (Should equal)!`)

	//some types come out looking the same when represented with "%#v" so we show type mismatch info:
	this.fail(so(StringAlias("hi"), ShouldResemble, "hi"), `hi|hi|Expected: "hi" Actual: assertions.StringAlias("hi") (Should equal)!`)
	this.pass(so(IntAlias(42), ShouldResemble, 42))

	type anyVal struct{ val any }
	this.fail(so(anyVal{123}, ShouldResemble, anyVal{int64(123)}), "{123}|{123}|Expected: assertions.anyVal{val:123} Actual: assertions.anyVal{val:123} (Should equal, but there is a type difference within the two)!")
}

func (this *AssertionsFixture) TestShouldNotResemble() {
	this.fail(so(Thing1{"hi"}, ShouldNotResemble), "This assertion requires exactly 1 comparison values (you provided 0).")
	this.fail(so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).")

	this.pass(so(Thing1{"hi"}, ShouldNotResemble, Thing1{"bye"}))
	this.fail(so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}), `Expected '{hi}' to NOT equal '{hi}' (but it did)!`)

	this.pass(so(map[string]string{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"}))
	this.fail(so(IntAlias(42), ShouldNotResemble, 42), `Expected '42' to NOT equal '42' (but it did)!`)

	this.pass(so(StringSliceAlias{"hi", "bye"}, ShouldNotResemble, []string{"hi", "bye"}))
}

func (this *AssertionsFixture) TestShouldEqualJSON() {
	this.fail(so("hi", ShouldEqualJSON), "This assertion requires exactly 1 comparison values (you provided 0).")
	this.fail(so("hi", ShouldEqualJSON, "hi", "hi"), "This assertion requires exactly 1 comparison values (you provided 2).")

	// basic identity of keys/values
	this.pass(so(`{"my":"val"}`, ShouldEqualJSON, `{"my":"val"}`))
	this.fail(so(`{"my":"val"}`, ShouldEqualJSON, `{"your":"val"}`),
		`{"your":"val"}|{"my":"val"}|Expected: "{\"your\":\"val\"}" Actual: "{\"my\":\"val\"}" (Should equal)! Diff: '"{\"myour\":\"val\"}"'`)

	// out of order values causes comparison failure:
	this.pass(so(`{"key0":"val0","key1":"val1"}`, ShouldEqualJSON, `{"key1":"val1","key0":"val0"}`))
	this.fail(so(`{"key0":"val0","key1":"val1"}`, ShouldEqualJSON, `{"key1":"val0","key0":"val0"}`),
		`{"key0":"val0","key1":"val0"}|{"key0":"val0","key1":"val1"}|Expected: "{\"key0\":\"val0\",\"key1\":\"val0\"}" Actual: "{\"key0\":\"val0\",\"key1\":\"val1\"}" (Should equal)! Diff: '"{\"key0\":\"val0\",\"key1\":\"val01\"}"'`)

	// missing values causes comparison failure:
	this.fail(so(
		`{"key0":"val0","key1":"val1"}`,
		ShouldEqualJSON,
		`{"key1":"val0"}`),
		`{"key1":"val0"}|{"key0":"val0","key1":"val1"}|Expected: "{\"key1\":\"val0\"}" Actual: "{\"key0\":\"val0\",\"key1\":\"val1\"}" (Should equal)! Diff: '"{\"key10\":\"val0\",\"key1\":\"val1\"}"'`)

	// whitespace shouldn't interfere with comparison:
	this.pass(so("\n{ \"my\"  :   \"val\"\n}", ShouldEqualJSON, `{"my":"val"}`))

	// Invalid JSON for either actual or expected value is invalid:
	this.fail(so("{}", ShouldEqualJSON, ""), "Expected value not valid JSON: unexpected end of JSON input")
	this.fail(so("", ShouldEqualJSON, "{}"), "Actual value not valid JSON: unexpected end of JSON input")

	// Support JSON array:
	this.pass(so("[]", ShouldEqualJSON, "[]"))

	// Support any JSON value:
	this.pass(so(`"hi"`, ShouldEqualJSON, `"hi"`))
	this.pass(so(`42`, ShouldEqualJSON, `42`))
	this.pass(so(`true`, ShouldEqualJSON, `true`))
	this.pass(so(`false`, ShouldEqualJSON, `false`))
	this.pass(so(`null`, ShouldEqualJSON, `null`))
}

func (this *AssertionsFixture) TestShouldPointTo() {
	t1 := &Thing1{}
	t2 := t1
	t3 := &Thing1{}

	pointer1 := reflect.ValueOf(t1).Pointer()
	pointer3 := reflect.ValueOf(t3).Pointer()

	this.fail(so(t1, ShouldPointTo), "This assertion requires exactly 1 comparison values (you provided 0).")
	this.fail(so(t1, ShouldPointTo, t2, t3), "This assertion requires exactly 1 comparison values (you provided 2).")

	this.pass(so(t1, ShouldPointTo, t2))
	this.fail(so(t1, ShouldPointTo, t3), fmt.Sprintf(
		"%v|%v|Expected '&{a:}' (address: '%v') and '&{a:}' (address: '%v') to be the same address (but their weren't)!",
		pointer3, pointer1, pointer1, pointer3))

	t4 := Thing1{}
	t5 := t4

	this.fail(so(t4, ShouldPointTo, t5), "Both arguments should be pointers (the first was not)!")
	this.fail(so(&t4, ShouldPointTo, t5), "Both arguments should be pointers (the second was not)!")
	this.fail(so(nil, ShouldPointTo, nil), "Both arguments should be pointers (the first was nil)!")
	this.fail(so(&t4, ShouldPointTo, nil), "Both arguments should be pointers (the second was nil)!")
}

func (this *AssertionsFixture) TestShouldNotPointTo() {
	t1 := &Thing1{}
	t2 := t1
	t3 := &Thing1{}

	pointer1 := reflect.ValueOf(t1).Pointer()

	this.fail(so(t1, ShouldNotPointTo), "This assertion requires exactly 1 comparison values (you provided 0).")
	this.fail(so(t1, ShouldNotPointTo, t2, t3), "This assertion requires exactly 1 comparison values (you provided 2).")

	this.pass(so(t1, ShouldNotPointTo, t3))
	this.fail(so(t1, ShouldNotPointTo, t2), fmt.Sprintf("Expected '&{a:}' and '&{a:}' to be different references (but they matched: '%v')!", pointer1))

	t4 := Thing1{}
	t5 := t4

	this.fail(so(t4, ShouldNotPointTo, t5), "Both arguments should be pointers (the first was not)!")
	this.fail(so(&t4, ShouldNotPointTo, t5), "Both arguments should be pointers (the second was not)!")
	this.fail(so(nil, ShouldNotPointTo, nil), "Both arguments should be pointers (the first was nil)!")
	this.fail(so(&t4, ShouldNotPointTo, nil), "Both arguments should be pointers (the second was nil)!")
}

func (this *AssertionsFixture) TestShouldBeNil() {
	this.fail(so(nil, ShouldBeNil, nil, nil, nil), "This assertion requires exactly 0 comparison values (you provided 3).")
	this.fail(so(nil, ShouldBeNil, nil), "This assertion requires exactly 0 comparison values (you provided 1).")

	this.pass(so(nil, ShouldBeNil))
	this.fail(so(1, ShouldBeNil), "Expected: nil Actual: '1'")

	var thing ThingInterface
	this.pass(so(thing, ShouldBeNil))
	thing = &ThingImplementation{}
	this.fail(so(thing, ShouldBeNil), "Expected: nil Actual: '&{}'")

	var thingOne *Thing1
	this.pass(so(thingOne, ShouldBeNil))

	var nilSlice []int = nil
	this.pass(so(nilSlice, ShouldBeNil))

	var nilMap map[string]string = nil
	this.pass(so(nilMap, ShouldBeNil))

	var nilChannel chan int = nil
	this.pass(so(nilChannel, ShouldBeNil))

	var nilFunc func() = nil
	this.pass(so(nilFunc, ShouldBeNil))

	var nilInterface any = nil
	this.pass(so(nilInterface, ShouldBeNil))
}

func (this *AssertionsFixture) TestShouldNotBeNil() {
	this.fail(so(nil, ShouldNotBeNil, nil, nil, nil), "This assertion requires exactly 0 comparison values (you provided 3).")
	this.fail(so(nil, ShouldNotBeNil, nil), "This assertion requires exactly 0 comparison values (you provided 1).")

	this.fail(so(nil, ShouldNotBeNil), "Expected '<nil>' to NOT be nil (but it was)!")
	this.pass(so(1, ShouldNotBeNil))

	var thing ThingInterface
	this.fail(so(thing, ShouldNotBeNil), "Expected '<nil>' to NOT be nil (but it was)!")
	thing = &ThingImplementation{}
	this.pass(so(thing, ShouldNotBeNil))
}

func (this *AssertionsFixture) TestShouldBeTrue() {
	this.fail(so(true, ShouldBeTrue, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).")
	this.fail(so(true, ShouldBeTrue, 1), "This assertion requires exactly 0 comparison values (you provided 1).")

	this.fail(so(false, ShouldBeTrue), "Expected: true Actual: false")
	this.fail(so(1, ShouldBeTrue), "Expected: true Actual: 1")
	this.pass(so(true, ShouldBeTrue))
}

func (this *AssertionsFixture) TestShouldBeFalse() {
	this.fail(so(false, ShouldBeFalse, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).")
	this.fail(so(false, ShouldBeFalse, 1), "This assertion requires exactly 0 comparison values (you provided 1).")

	this.fail(so(true, ShouldBeFalse), "Expected: false Actual: true")
	this.fail(so(1, ShouldBeFalse), "Expected: false Actual: 1")
	this.pass(so(false, ShouldBeFalse))
}

func (this *AssertionsFixture) TestShouldBeZeroValue() {
	this.fail(so(0, ShouldBeZeroValue, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).")
	this.fail(so(false, ShouldBeZeroValue, true), "This assertion requires exactly 0 comparison values (you provided 1).")

	this.fail(so(1, ShouldBeZeroValue), "0|1|'1' should have been the zero value")                                       //"Expected: (zero value) Actual: 1")
	this.fail(so(true, ShouldBeZeroValue), "false|true|'true' should have been the zero value")                          //"Expected: (zero value) Actual: true")
	this.fail(so("123", ShouldBeZeroValue), "|123|'123' should have been the zero value")                                //"Expected: (zero value) Actual: 123")
	this.fail(so(" ", ShouldBeZeroValue), "| |' ' should have been the zero value")                                      //"Expected: (zero value) Actual:  ")
	this.fail(so([]string{"Nonempty"}, ShouldBeZeroValue), "[]|[Nonempty]|'[Nonempty]' should have been the zero value") //"Expected: (zero value) Actual: [Nonempty]")
	this.fail(so(struct{ a string }{a: "asdf"}, ShouldBeZeroValue), "{}|{asdf}|'{a:asdf}' should have been the zero value")
	this.pass(so(0, ShouldBeZeroValue))
	this.pass(so(false, ShouldBeZeroValue))
	this.pass(so("", ShouldBeZeroValue))
	this.pass(so(struct{}{}, ShouldBeZeroValue))
}

func (this *AssertionsFixture) TestShouldNotBeZeroValue() {
	this.fail(so(0, ShouldNotBeZeroValue, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).")
	this.fail(so(false, ShouldNotBeZeroValue, true), "This assertion requires exactly 0 comparison values (you provided 1).")

	this.fail(so(0, ShouldNotBeZeroValue), "0|0|'0' should NOT have been the zero value")
	this.fail(so(false, ShouldNotBeZeroValue), "false|false|'false' should NOT have been the zero value")
	this.fail(so("", ShouldNotBeZeroValue), "||'' should NOT have been the zero value")
	this.fail(so(struct{}{}, ShouldNotBeZeroValue), "{}|{}|'{}' should NOT have been the zero value")

	this.pass(so(1, ShouldNotBeZeroValue))
	this.pass(so(true, ShouldNotBeZeroValue))
	this.pass(so("123", ShouldNotBeZeroValue))
	this.pass(so(" ", ShouldNotBeZeroValue))
	this.pass(so([]string{"Nonempty"}, ShouldNotBeZeroValue))
	this.pass(so(struct{ a string }{a: "asdf"}, ShouldNotBeZeroValue))
}