1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
// Copyright 2017, The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package teststructs
type InterfaceA interface {
InterfaceA()
}
type (
StructA struct{ X string } // Equal method on value receiver
StructB struct{ X string } // Equal method on pointer receiver
StructC struct{ X string } // Equal method (with interface argument) on value receiver
StructD struct{ X string } // Equal method (with interface argument) on pointer receiver
StructE struct{ X string } // Equal method (with interface argument on value receiver) on pointer receiver
StructF struct{ X string } // Equal method (with interface argument on pointer receiver) on value receiver
// These embed the above types as a value.
StructA1 struct {
StructA
X string
}
StructB1 struct {
StructB
X string
}
StructC1 struct {
StructC
X string
}
StructD1 struct {
StructD
X string
}
StructE1 struct {
StructE
X string
}
StructF1 struct {
StructF
X string
}
// These embed the above types as a pointer.
StructA2 struct {
*StructA
X string
}
StructB2 struct {
*StructB
X string
}
StructC2 struct {
*StructC
X string
}
StructD2 struct {
*StructD
X string
}
StructE2 struct {
*StructE
X string
}
StructF2 struct {
*StructF
X string
}
StructNo struct{ X string } // Equal method (with interface argument) on non-satisfying receiver
AssignA func() int
AssignB struct{ A int }
AssignC chan bool
AssignD <-chan bool
)
func (x StructA) Equal(y StructA) bool { return true }
func (x *StructB) Equal(y *StructB) bool { return true }
func (x StructC) Equal(y InterfaceA) bool { return true }
func (x StructC) InterfaceA() {}
func (x *StructD) Equal(y InterfaceA) bool { return true }
func (x *StructD) InterfaceA() {}
func (x *StructE) Equal(y InterfaceA) bool { return true }
func (x StructE) InterfaceA() {}
func (x StructF) Equal(y InterfaceA) bool { return true }
func (x *StructF) InterfaceA() {}
func (x StructNo) Equal(y InterfaceA) bool { return true }
func (x AssignA) Equal(y func() int) bool { return true }
func (x AssignB) Equal(y struct{ A int }) bool { return true }
func (x AssignC) Equal(y chan bool) bool { return true }
func (x AssignD) Equal(y <-chan bool) bool { return true }
var _ = func(
a StructA, b StructB, c StructC, d StructD, e StructE, f StructF,
ap *StructA, bp *StructB, cp *StructC, dp *StructD, ep *StructE, fp *StructF,
a1 StructA1, b1 StructB1, c1 StructC1, d1 StructD1, e1 StructE1, f1 StructF1,
a2 StructA2, b2 StructB2, c2 StructC2, d2 StructD2, e2 StructE2, f2 StructF1,
) {
a.Equal(a)
b.Equal(&b)
c.Equal(c)
d.Equal(&d)
e.Equal(e)
f.Equal(&f)
ap.Equal(*ap)
bp.Equal(bp)
cp.Equal(*cp)
dp.Equal(dp)
ep.Equal(*ep)
fp.Equal(fp)
a1.Equal(a1.StructA)
b1.Equal(&b1.StructB)
c1.Equal(c1)
d1.Equal(&d1)
e1.Equal(e1)
f1.Equal(&f1)
a2.Equal(*a2.StructA)
b2.Equal(b2.StructB)
c2.Equal(c2)
d2.Equal(&d2)
e2.Equal(e2)
f2.Equal(&f2)
}
type (
privateStruct struct{ Public, private int }
PublicStruct struct{ Public, private int }
ParentStructA struct{ privateStruct }
ParentStructB struct{ PublicStruct }
ParentStructC struct {
privateStruct
Public, private int
}
ParentStructD struct {
PublicStruct
Public, private int
}
ParentStructE struct {
privateStruct
PublicStruct
}
ParentStructF struct {
privateStruct
PublicStruct
Public, private int
}
ParentStructG struct {
*privateStruct
}
ParentStructH struct {
*PublicStruct
}
ParentStructI struct {
*privateStruct
*PublicStruct
}
ParentStructJ struct {
*privateStruct
*PublicStruct
Public PublicStruct
private privateStruct
}
)
func NewParentStructG() *ParentStructG {
return &ParentStructG{new(privateStruct)}
}
func NewParentStructH() *ParentStructH {
return &ParentStructH{new(PublicStruct)}
}
func NewParentStructI() *ParentStructI {
return &ParentStructI{new(privateStruct), new(PublicStruct)}
}
func NewParentStructJ() *ParentStructJ {
return &ParentStructJ{
privateStruct: new(privateStruct), PublicStruct: new(PublicStruct),
}
}
func (s *privateStruct) SetPrivate(i int) { s.private = i }
func (s *PublicStruct) SetPrivate(i int) { s.private = i }
func (s *ParentStructC) SetPrivate(i int) { s.private = i }
func (s *ParentStructD) SetPrivate(i int) { s.private = i }
func (s *ParentStructF) SetPrivate(i int) { s.private = i }
func (s *ParentStructA) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructC) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructE) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructF) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructG) PrivateStruct() *privateStruct { return s.privateStruct }
func (s *ParentStructI) PrivateStruct() *privateStruct { return s.privateStruct }
func (s *ParentStructJ) PrivateStruct() *privateStruct { return s.privateStruct }
func (s *ParentStructJ) Private() *privateStruct { return &s.private }
|
