.gitignore added

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / github.com / google / go-cmp@v0.5.4 / cmp / internal / teststructs / structs.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/google/go-cmp@v0.5.4/cmp/internal/teststructs/structs.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/google/go-cmp@v0.5.4/cmp/internal/teststructs/structs.go
new file mode 100644 (file)
index 0000000..bfd2de8
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/google/go-cmp@v0.5.4/cmp/internal/teststructs/structs.go
@@ -0,0 +1,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 }