我有以下结构，每个字段都有 getter

```
type Profile struct {
    id        dom.ID
    screeName ScreenName
    dob       DOB
    gender    Gender
    bio       Bio
    avatar    Avatar
    company   Company
    website   Website
    address   address.Address
    accounts  []dom.ID
}
```

每个字段的类型只是字符串的包装器，用于进行一些验证或其他操作。 setter/getter 都是相同的格式，

```
// ScreenName returns the ScreenName for the profile
func (p *Profile) ScreenName() ScreenName {
    return p.screeName
}

// DOB returns the dob for the profile
func (p *Profile) DOB() DOB {
    return p.dob
}
```

下面是构造函数，如果没有提供设置结构字段的选项，则会为其提供随机默认值。

```
type Option func(prof *Profile)

func New(opts ...Option) *Profile {
    p := newWithAllDefaults()
    for _, opt := range opts {
        opt(p)
    }
    return p
}
```

可以传递给构造函数的所有选项类型都经过测试并在 Profile 结构上设置非导出字段。

现在我遇到的问题是测试。我现在只使用 go 大概 3 个月，所以我确信我在这里遗漏了一些东西，但是在我的测试中使用 reflect.deepEqual() 时，我总是得到意想不到的结果。使用简单的标量值，它可以按预期工作，但我不知道为什么我期望通过的测试失败了，而我期望失败的测试却通过了。

这里是有问题的测试。

```
func TestNew(t *testing.T) {
    _ = media.SetDefaults("../../../assets/", "../../../assets/Go_gopher_mascot_bw.png")
    type args struct {
        opts []Option
    }
    tests := []struct {
        name string
        args args
        want *Profile
    }{
        {name: "New should return a Profile with the correct gender set", args: args{[]Option{WithGender("male")}}, want: New(WithGender("male"))},
        {name: "New should return a Profile with the correct Avatar set", args: args{[]Option{WithAvatar("../../../assets/picture12371854532127.png")}}, want: New(WithAvatar("../../../assets/picture12371854532127.png"))},
        {name: "New should return a Profile with the correct DOB set", args: args{[]Option{WithDOB(1982, 06, 18)}}, want: New(WithDOB(1982, 06, 18))},
        {name: "New should return a Profile with the correct ScreenName set", args: args{[]Option{WithScreenName("Lars Bak")}}, want: New(WithScreenName("Lars Bak"))},
    }
    for i, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {

            switch i {
            case 1:
                if got := New(tt.args.opts...); !reflect.DeepEqual(got.Gender(), tt.want.gender) {
                    t.Errorf("New() = %v, want %v", got, tt.want)
                }
            case 2:
                if got := New(tt.args.opts...); !reflect.DeepEqual(got.avatar, tt.want.Avatar()) {
                    t.Errorf("New() = %v, want %v", got, tt.want)
                }
            case 3:
                if got := New(tt.args.opts...); !reflect.DeepEqual(got.DOB(), tt.want.dob) {
                    t.Errorf("New() = %v, want %v", got, tt.want)
                }
            case 4:
                if got := New(tt.args.opts...); !reflect.DeepEqual(got.screeName, tt.want.screeName) {
                    t.Errorf("New() = %v, want %v", got.screeName, tt.want.screeName)
                }
            }
        })

    }
}
```

我不明白的是为什么第 4 次测试失败了，为什么如果我更改我的其他测试以便它们在字段集上没有相同的值，那些测试仍然通过？

这是测试结果。

```
=== RUN   TestNew
--- FAIL: TestNew (0.00s)
=== RUN   TestNew/New_should_return_a_Profile_with_the_correct_gender_set
    --- PASS: TestNew/New_should_return_a_Profile_with_the_correct_gender_set (0.00s)
=== RUN   TestNew/New_should_return_a_Profile_with_the_correct_Avatar_set
    --- PASS: TestNew/New_should_return_a_Profile_with_the_correct_Avatar_set (0.00s)
=== RUN   TestNew/New_should_return_a_Profile_with_the_correct_DOB_set
    --- PASS: TestNew/New_should_return_a_Profile_with_the_correct_DOB_set (0.00s)
=== RUN   TestNew/New_should_return_a_Profile_with_the_correct_ScreenName_set
    --- FAIL: TestNew/New_should_return_a_Profile_with_the_correct_ScreenName_set (0.00s)
        profile_test.go:57: New() = &{[194 90 188 29 133 134 77 43 153 32 125 223 208 91 163 84] Lars Bak {1997 9 13} 0 West-Kshlerin ../../../assets/Go_gopher_mascot_bw.png Medhurst-Flatley 0xc000221e80 {SENEGAL   [882 Meadowshire]  Hauckberg South Carolina 13885 } []}, want &{[219 147 211 8 80 39 74 19 172 10 138 10 2 50 228 153] Lars Bak {1989 9 16} 0 Olson, Nolan and Abbott ../../../assets/Go_gopher_mascot_bw.png Feeney and Sons 0xc000221d00 {EGYPT   [84658 Wellstad]  Raulburgh Montana 42634 } []}
FAIL
```

我对为什么 t.Errorf 函数似乎正在比较和打印整个结构感到困惑。希望弄清楚我在这里做错了什么。

谢谢。

最佳答案

i 将从零开始，因此在您的第 4 个测试中，您将进入 switch 中的第 3 个语句并比较您可以从输出中看到的不同出生日期。第三个 case 语句也打印出完整的结构。

关于go - 为什么这个测试使用 reflect.deepEqual 会失败？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54140265/