structs.go

Documentation: github.com/google/go-cmp/cmp/internal/teststructs

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