.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/google/go-cmp@v0.5.4/cmp/testdata/diffs

   1 <<< TestDiff/Comparer/StructInequal
   2   struct{ A int; B int; C int }{
   3         A: 1,
   4         B: 2,
   5 -       C: 3,
   6 +       C: 4,
   7   }
   8 >>> TestDiff/Comparer/StructInequal
   9 <<< TestDiff/Comparer/PointerStructInequal
  10   &struct{ A *int }{
  11 -       A: &4,
  12 +       A: &5,
  13   }
  14 >>> TestDiff/Comparer/PointerStructInequal
  15 <<< TestDiff/Comparer/StructNestedPointerInequal
  16   &struct{ R *bytes.Buffer }{
  17 -       R: s"",
  18 +       R: nil,
  19   }
  20 >>> TestDiff/Comparer/StructNestedPointerInequal
  21 <<< TestDiff/Comparer/RegexpInequal
  22   []*regexp.Regexp{
  23         nil,
  24 -       s"a*b*c*",
  25 +       s"a*b*d*",
  26   }
  27 >>> TestDiff/Comparer/RegexpInequal
  28 <<< TestDiff/Comparer/TriplePointerInequal
  29   &&&int(
  30 -       0,
  31 +       1,
  32   )
  33 >>> TestDiff/Comparer/TriplePointerInequal
  34 <<< TestDiff/Comparer/StringerInequal
  35   struct{ fmt.Stringer }(
  36 -       s"hello",
  37 +       s"hello2",
  38   )
  39 >>> TestDiff/Comparer/StringerInequal
  40 <<< TestDiff/Comparer/DifferingHash
  41   [16]uint8{
  42 -       0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8, 0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61,
  43 +       0x92, 0xeb, 0x5f, 0xfe, 0xe6, 0xae, 0x2f, 0xec, 0x3a, 0xd7, 0x1c, 0x77, 0x75, 0x31, 0x57, 0x8f,
  44   }
  45 >>> TestDiff/Comparer/DifferingHash
  46 <<< TestDiff/Comparer/NilStringer
  47   interface{}(
  48 -       &fmt.Stringer(nil),
  49   )
  50 >>> TestDiff/Comparer/NilStringer
  51 <<< TestDiff/Comparer/TarHeaders
  52   []cmp_test.tarHeader{
  53         {
  54                 ... // 4 identical fields
  55                 Size:     1,
  56                 ModTime:  s"2009-11-10 23:00:00 +0000 UTC",
  57 -               Typeflag: 48,
  58 +               Typeflag: 0,
  59                 Linkname: "",
  60                 Uname:    "user",
  61                 ... // 6 identical fields
  62         },
  63         {
  64                 ... // 4 identical fields
  65                 Size:     2,
  66                 ModTime:  s"2009-11-11 00:00:00 +0000 UTC",
  67 -               Typeflag: 48,
  68 +               Typeflag: 0,
  69                 Linkname: "",
  70                 Uname:    "user",
  71                 ... // 6 identical fields
  72         },
  73         {
  74                 ... // 4 identical fields
  75                 Size:     4,
  76                 ModTime:  s"2009-11-11 01:00:00 +0000 UTC",
  77 -               Typeflag: 48,
  78 +               Typeflag: 0,
  79                 Linkname: "",
  80                 Uname:    "user",
  81                 ... // 6 identical fields
  82         },
  83         {
  84                 ... // 4 identical fields
  85                 Size:     8,
  86                 ModTime:  s"2009-11-11 02:00:00 +0000 UTC",
  87 -               Typeflag: 48,
  88 +               Typeflag: 0,
  89                 Linkname: "",
  90                 Uname:    "user",
  91                 ... // 6 identical fields
  92         },
  93         {
  94                 ... // 4 identical fields
  95                 Size:     16,
  96                 ModTime:  s"2009-11-11 03:00:00 +0000 UTC",
  97 -               Typeflag: 48,
  98 +               Typeflag: 0,
  99                 Linkname: "",
 100                 Uname:    "user",
 101                 ... // 6 identical fields
 102         },
 103   }
 104 >>> TestDiff/Comparer/TarHeaders
 105 <<< TestDiff/Comparer/IrreflexiveComparison
 106   []int{
 107 -       Inverse(λ, float64(NaN)),
 108 +       Inverse(λ, float64(NaN)),
 109 -       Inverse(λ, float64(NaN)),
 110 +       Inverse(λ, float64(NaN)),
 111 -       Inverse(λ, float64(NaN)),
 112 +       Inverse(λ, float64(NaN)),
 113 -       Inverse(λ, float64(NaN)),
 114 +       Inverse(λ, float64(NaN)),
 115 -       Inverse(λ, float64(NaN)),
 116 +       Inverse(λ, float64(NaN)),
 117 -       Inverse(λ, float64(NaN)),
 118 +       Inverse(λ, float64(NaN)),
 119 -       Inverse(λ, float64(NaN)),
 120 +       Inverse(λ, float64(NaN)),
 121 -       Inverse(λ, float64(NaN)),
 122 +       Inverse(λ, float64(NaN)),
 123 -       Inverse(λ, float64(NaN)),
 124 +       Inverse(λ, float64(NaN)),
 125 -       Inverse(λ, float64(NaN)),
 126 +       Inverse(λ, float64(NaN)),
 127   }
 128 >>> TestDiff/Comparer/IrreflexiveComparison
 129 <<< TestDiff/Comparer/StringerMapKey
 130   map[*testprotos.Stringer]*testprotos.Stringer(
 131 -       {s"hello": s"world"},
 132 +       nil,
 133   )
 134 >>> TestDiff/Comparer/StringerMapKey
 135 <<< TestDiff/Comparer/StringerBacktick
 136   interface{}(
 137 -       []*testprotos.Stringer{s`multi\nline\nline\nline`},
 138   )
 139 >>> TestDiff/Comparer/StringerBacktick
 140 <<< TestDiff/Comparer/DynamicMap
 141   []interface{}{
 142         map[string]interface{}{
 143                 "avg":  float64(0.278),
 144 -               "hr":   int(65),
 145 +               "hr":   float64(65),
 146                 "name": string("Mark McGwire"),
 147         },
 148         map[string]interface{}{
 149                 "avg":  float64(0.288),
 150 -               "hr":   int(63),
 151 +               "hr":   float64(63),
 152                 "name": string("Sammy Sosa"),
 153         },
 154   }
 155 >>> TestDiff/Comparer/DynamicMap
 156 <<< TestDiff/Comparer/MapKeyPointer
 157   map[*int]string{
 158 -       &⟪0xdeadf00f⟫0: "hello",
 159 +       &⟪0xdeadf00f⟫0: "world",
 160   }
 161 >>> TestDiff/Comparer/MapKeyPointer
 162 <<< TestDiff/Comparer/IgnoreSliceElements
 163   [2][]int{
 164         {..., 1, 2, 3, ...},
 165         {
 166                 ... // 6 ignored and 1 identical elements
 167 -               20,
 168 +               2,
 169                 ... // 3 ignored elements
 170         },
 171   }
 172 >>> TestDiff/Comparer/IgnoreSliceElements
 173 <<< TestDiff/Comparer/IgnoreMapEntries
 174   [2]map[string]int{
 175         {"KEEP3": 3, "keep1": 1, "keep2": 2, ...},
 176         {
 177                 ... // 2 ignored entries
 178                 "keep1": 1,
 179 +               "keep2": 2,
 180         },
 181   }
 182 >>> TestDiff/Comparer/IgnoreMapEntries
 183 <<< TestDiff/Transformer/Uints
 184   uint8(Inverse(λ, uint16(Inverse(λ, uint32(Inverse(λ, uint64(
 185 -       0,
 186 +       1,
 187   )))))))
 188 >>> TestDiff/Transformer/Uints
 189 <<< TestDiff/Transformer/Filtered
 190   []int{
 191         Inverse(λ, int64(0)),
 192 -       Inverse(λ, int64(-5)),
 193 +       Inverse(λ, int64(3)),
 194         Inverse(λ, int64(0)),
 195 -       Inverse(λ, int64(-1)),
 196 +       Inverse(λ, int64(-5)),
 197   }
 198 >>> TestDiff/Transformer/Filtered
 199 <<< TestDiff/Transformer/DisjointOutput
 200   int(Inverse(λ, interface{}(
 201 -       string("zero"),
 202 +       float64(1),
 203   )))
 204 >>> TestDiff/Transformer/DisjointOutput
 205 <<< TestDiff/Transformer/JSON
 206   string(Inverse(ParseJSON, map[string]interface{}{
 207         "address": map[string]interface{}{
 208 -               "city":          string("Los Angeles"),
 209 +               "city":          string("New York"),
 210                 "postalCode":    string("10021-3100"),
 211 -               "state":         string("CA"),
 212 +               "state":         string("NY"),
 213                 "streetAddress": string("21 2nd Street"),
 214         },
 215         "age":       float64(25),
 216         "children":  []interface{}{},
 217         "firstName": string("John"),
 218         "isAlive":   bool(true),
 219         "lastName":  string("Smith"),
 220         "phoneNumbers": []interface{}{
 221                 map[string]interface{}{
 222 -                       "number": string("212 555-4321"),
 223 +                       "number": string("212 555-1234"),
 224                         "type":   string("home"),
 225                 },
 226                 map[string]interface{}{"number": string("646 555-4567"), "type": string("office")},
 227                 map[string]interface{}{"number": string("123 456-7890"), "type": string("mobile")},
 228         },
 229 +       "spouse": nil,
 230   }))
 231 >>> TestDiff/Transformer/JSON
 232 <<< TestDiff/Transformer/AcyclicString
 233   cmp_test.StringBytes{
 234         String: Inverse(SplitString, []string{
 235                 "some",
 236                 "multi",
 237 -               "Line",
 238 +               "line",
 239                 "string",
 240         }),
 241         Bytes: []uint8(Inverse(SplitBytes, [][]uint8{
 242                 {0x73, 0x6f, 0x6d, 0x65},
 243                 {0x6d, 0x75, 0x6c, 0x74, ...},
 244                 {0x6c, 0x69, 0x6e, 0x65},
 245                 {
 246 -                       0x62,
 247 +                       0x42,
 248                         0x79,
 249                         0x74,
 250                         ... // 2 identical elements
 251                 },
 252         })),
 253   }
 254 >>> TestDiff/Transformer/AcyclicString
 255 <<< TestDiff/Reporter/PanicStringer
 256   struct{ X fmt.Stringer }{
 257 -       X: struct{ fmt.Stringer }{},
 258 +       X: s"",
 259   }
 260 >>> TestDiff/Reporter/PanicStringer
 261 <<< TestDiff/Reporter/PanicError
 262   struct{ X error }{
 263 -       X: struct{ error }{},
 264 +       X: e"",
 265   }
 266 >>> TestDiff/Reporter/PanicError
 267 <<< TestDiff/Reporter/AmbiguousType
 268   interface{}(
 269 -       "github.com/google/go-cmp/cmp/internal/teststructs/foo1".Bar{},
 270 +       "github.com/google/go-cmp/cmp/internal/teststructs/foo2".Bar{},
 271   )
 272 >>> TestDiff/Reporter/AmbiguousType
 273 <<< TestDiff/Reporter/AmbiguousPointer
 274   (*int)(
 275 -       &⟪0xdeadf00f⟫0,
 276 +       &⟪0xdeadf00f⟫0,
 277   )
 278 >>> TestDiff/Reporter/AmbiguousPointer
 279 <<< TestDiff/Reporter/AmbiguousPointerStruct
 280   struct{ I *int }{
 281 -       I: &⟪0xdeadf00f⟫0,
 282 +       I: &⟪0xdeadf00f⟫0,
 283   }
 284 >>> TestDiff/Reporter/AmbiguousPointerStruct
 285 <<< TestDiff/Reporter/AmbiguousPointerSlice
 286   []*int{
 287 -       &⟪0xdeadf00f⟫0,
 288 +       &⟪0xdeadf00f⟫0,
 289   }
 290 >>> TestDiff/Reporter/AmbiguousPointerSlice
 291 <<< TestDiff/Reporter/AmbiguousPointerMap
 292   map[string]*int{
 293 -       "zero": &⟪0xdeadf00f⟫0,
 294 +       "zero": &⟪0xdeadf00f⟫0,
 295   }
 296 >>> TestDiff/Reporter/AmbiguousPointerMap
 297 <<< TestDiff/Reporter/AmbiguousStringer
 298   interface{}(
 299 -       cmp_test.Stringer("hello"),
 300 +       &cmp_test.Stringer("hello"),
 301   )
 302 >>> TestDiff/Reporter/AmbiguousStringer
 303 <<< TestDiff/Reporter/AmbiguousStringerStruct
 304   struct{ S fmt.Stringer }{
 305 -       S: cmp_test.Stringer("hello"),
 306 +       S: &cmp_test.Stringer("hello"),
 307   }
 308 >>> TestDiff/Reporter/AmbiguousStringerStruct
 309 <<< TestDiff/Reporter/AmbiguousStringerSlice
 310   []fmt.Stringer{
 311 -       cmp_test.Stringer("hello"),
 312 +       &cmp_test.Stringer("hello"),
 313   }
 314 >>> TestDiff/Reporter/AmbiguousStringerSlice
 315 <<< TestDiff/Reporter/AmbiguousStringerMap
 316   map[string]fmt.Stringer{
 317 -       "zero": cmp_test.Stringer("hello"),
 318 +       "zero": &cmp_test.Stringer("hello"),
 319   }
 320 >>> TestDiff/Reporter/AmbiguousStringerMap
 321 <<< TestDiff/Reporter/AmbiguousSliceHeader
 322   []int(
 323 -       ⟪ptr:0xdeadf00f, len:0, cap:5⟫{},
 324 +       ⟪ptr:0xdeadf00f, len:0, cap:1000⟫{},
 325   )
 326 >>> TestDiff/Reporter/AmbiguousSliceHeader
 327 <<< TestDiff/Reporter/AmbiguousStringerMapKey
 328   map[interface{}]string{
 329 -       nil:                                                                     "nil",
 330 +       &⟪0xdeadf00f⟫"github.com/google/go-cmp/cmp_test".Stringer("hello"):      "goodbye",
 331 -       "github.com/google/go-cmp/cmp_test".Stringer("hello"):                   "goodbye",
 332 -       "github.com/google/go-cmp/cmp/internal/teststructs/foo1".Bar{S: "fizz"}: "buzz",
 333 +       "github.com/google/go-cmp/cmp/internal/teststructs/foo2".Bar{S: "fizz"}: "buzz",
 334   }
 335 >>> TestDiff/Reporter/AmbiguousStringerMapKey
 336 <<< TestDiff/Reporter/NonAmbiguousStringerMapKey
 337   map[interface{}]string{
 338 +       s"fizz":  "buzz",
 339 -       s"hello": "goodbye",
 340   }
 341 >>> TestDiff/Reporter/NonAmbiguousStringerMapKey
 342 <<< TestDiff/Reporter/InvalidUTF8
 343   interface{}(
 344 -       cmp_test.MyString("\xed\xa0\x80"),
 345   )
 346 >>> TestDiff/Reporter/InvalidUTF8
 347 <<< TestDiff/Reporter/UnbatchedSlice
 348   cmp_test.MyComposite{
 349         ... // 3 identical fields
 350         BytesB: nil,
 351         BytesC: nil,
 352         IntsA: []int8{
 353 +               10,
 354                 11,
 355 -               12,
 356 +               21,
 357                 13,
 358                 14,
 359                 ... // 15 identical elements
 360         },
 361         IntsB: nil,
 362         IntsC: nil,
 363         ... // 6 identical fields
 364   }
 365 >>> TestDiff/Reporter/UnbatchedSlice
 366 <<< TestDiff/Reporter/BatchedSlice
 367   cmp_test.MyComposite{
 368         ... // 3 identical fields
 369         BytesB: nil,
 370         BytesC: nil,
 371         IntsA: []int8{
 372 -               10, 11, 12, 13, 14, 15, 16,
 373 +               12, 29, 13, 27, 22, 23,
 374                 17, 18, 19, 20, 21,
 375 -               22, 23, 24, 25, 26, 27, 28, 29,
 376 +               10, 26, 16, 25, 28, 11, 15, 24, 14,
 377         },
 378         IntsB: nil,
 379         IntsC: nil,
 380         ... // 6 identical fields
 381   }
 382 >>> TestDiff/Reporter/BatchedSlice
 383 <<< TestDiff/Reporter/BatchedWithComparer
 384   cmp_test.MyComposite{
 385         StringA: "",
 386         StringB: "",
 387         BytesA: []uint8{
 388 -               0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,             // -|.......|
 389 +               0x0c, 0x1d, 0x0d, 0x1b, 0x16, 0x17,                   // +|......|
 390                 0x11, 0x12, 0x13, 0x14, 0x15,                         //  |.....|
 391 -               0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,       // -|........|
 392 +               0x0a, 0x1a, 0x10, 0x19, 0x1c, 0x0b, 0x0f, 0x18, 0x0e, // +|.........|
 393         },
 394         BytesB: nil,
 395         BytesC: nil,
 396         ... // 9 identical fields
 397   }
 398 >>> TestDiff/Reporter/BatchedWithComparer
 399 <<< TestDiff/Reporter/BatchedLong
 400   interface{}(
 401 -       cmp_test.MyComposite{IntsA: []int8{0, 1, 2, 3, 4, 5, 6, 7, ...}},
 402   )
 403 >>> TestDiff/Reporter/BatchedLong
 404 <<< TestDiff/Reporter/BatchedNamedAndUnnamed
 405   cmp_test.MyComposite{
 406         StringA: "",
 407         StringB: "",
 408         BytesA: []uint8{
 409 -               0x01, 0x02, 0x03, // -|...|
 410 +               0x03, 0x02, 0x01, // +|...|
 411         },
 412         BytesB: []cmp_test.MyByte{
 413 -               0x04, 0x05, 0x06,
 414 +               0x06, 0x05, 0x04,
 415         },
 416         BytesC: cmp_test.MyBytes{
 417 -               0x07, 0x08, 0x09, // -|...|
 418 +               0x09, 0x08, 0x07, // +|...|
 419         },
 420         IntsA: []int8{
 421 -               -1, -2, -3,
 422 +               -3, -2, -1,
 423         },
 424         IntsB: []cmp_test.MyInt{
 425 -               -4, -5, -6,
 426 +               -6, -5, -4,
 427         },
 428         IntsC: cmp_test.MyInts{
 429 -               -7, -8, -9,
 430 +               -9, -8, -7,
 431         },
 432         UintsA: []uint16{
 433 -               1000, 2000, 3000,
 434 +               3000, 2000, 1000,
 435         },
 436         UintsB: []cmp_test.MyUint{
 437 -               4000, 5000, 6000,
 438 +               6000, 5000, 4000,
 439         },
 440         UintsC: cmp_test.MyUints{
 441 -               7000, 8000, 9000,
 442 +               9000, 8000, 7000,
 443         },
 444         FloatsA: []float32{
 445 -               1.5, 2.5, 3.5,
 446 +               3.5, 2.5, 1.5,
 447         },
 448         FloatsB: []cmp_test.MyFloat{
 449 -               4.5, 5.5, 6.5,
 450 +               6.5, 5.5, 4.5,
 451         },
 452         FloatsC: cmp_test.MyFloats{
 453 -               7.5, 8.5, 9.5,
 454 +               9.5, 8.5, 7.5,
 455         },
 456   }
 457 >>> TestDiff/Reporter/BatchedNamedAndUnnamed
 458 <<< TestDiff/Reporter/BinaryHexdump
 459   cmp_test.MyComposite{
 460         StringA: "",
 461         StringB: "",
 462         BytesA: []uint8{
 463                 0xf3, 0x0f, 0x8a, 0xa4, 0xd3, 0x12, 0x52, 0x09, 0x24, 0xbe,                                     //  |......R.$.|
 464 -               0x58, 0x95, 0x41, 0xfd, 0x24, 0x66, 0x58, 0x8b, 0x79,                                           // -|X.A.$fX.y|
 465                 0x54, 0xac, 0x0d, 0xd8, 0x71, 0x77, 0x70, 0x20, 0x6a, 0x5c, 0x73, 0x7f, 0x8c, 0x17, 0x55, 0xc0, //  |T...qwp j\s...U.|
 466                 0x34, 0xce, 0x6e, 0xf7, 0xaa, 0x47, 0xee, 0x32, 0x9d, 0xc5, 0xca, 0x1e, 0x58, 0xaf, 0x8f, 0x27, //  |4.n..G.2....X..'|
 467                 0xf3, 0x02, 0x4a, 0x90, 0xed, 0x69, 0x2e, 0x70, 0x32, 0xb4, 0xab, 0x30, 0x20, 0xb6, 0xbd, 0x5c, //  |..J..i.p2..0 ..\|
 468                 0x62, 0x34, 0x17, 0xb0, 0x00, 0xbb, 0x4f, 0x7e, 0x27, 0x47, 0x06, 0xf4, 0x2e, 0x66, 0xfd, 0x63, //  |b4....O~'G...f.c|
 469                 0xd7, 0x04, 0xdd, 0xb7, 0x30, 0xb7, 0xd1,                                                       //  |....0..|
 470 -               0x55, 0x7e, 0x7b, 0xf6, 0xb3, 0x7e, 0x1d, 0x57, 0x69,                                           // -|U~{..~.Wi|
 471 +               0x75, 0x2d, 0x5b, 0x5d, 0x5d, 0xf6, 0xb3, 0x68, 0x61, 0x68, 0x61, 0x7e, 0x1d, 0x57, 0x49,       // +|u-[]]..haha~.WI|
 472                 0x20, 0x9e, 0xbc, 0xdf, 0xe1, 0x4d, 0xa9, 0xef, 0xa2, 0xd2, 0xed, 0xb4, 0x47, 0x78, 0xc9, 0xc9, //  | ....M......Gx..|
 473                 0x27, 0xa4, 0xc6, 0xce, 0xec, 0x44, 0x70, 0x5d,                                                 //  |'....Dp]|
 474         },
 475         BytesB: nil,
 476         BytesC: nil,
 477         ... // 9 identical fields
 478   }
 479 >>> TestDiff/Reporter/BinaryHexdump
 480 <<< TestDiff/Reporter/StringHexdump
 481   cmp_test.MyComposite{
 482         StringA: "",
 483         StringB: cmp_test.MyString{
 484 -               0x72, 0x65, 0x61, 0x64, 0x6d, 0x65,                                                             // -|readme|
 485 +               0x67, 0x6f, 0x70, 0x68, 0x65, 0x72,                                                             // +|gopher|
 486                 0x2e, 0x74, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //  |.txt............|
 487                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //  |................|
 488                 ... // 64 identical bytes
 489                 0x30, 0x30, 0x36, 0x30, 0x30, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x30, //  |00600.0000000.00|
 490                 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, //  |00000.0000000004|
 491 -               0x36,                                                                                           // -|6|
 492 +               0x33,                                                                                           // +|3|
 493                 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x31, 0x31, //  |.00000000000.011|
 494 -               0x31, 0x37, 0x33,                                                                               // -|173|
 495 +               0x32, 0x31, 0x37,                                                                               // +|217|
 496                 0x00, 0x20, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //  |. 0.............|
 497                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //  |................|
 498                 ... // 326 identical bytes
 499         },
 500         BytesA: nil,
 501         BytesB: nil,
 502         ... // 10 identical fields
 503   }
 504 >>> TestDiff/Reporter/StringHexdump
 505 <<< TestDiff/Reporter/BinaryString
 506   cmp_test.MyComposite{
 507         StringA: "",
 508         StringB: "",
 509         BytesA: bytes.Join({
 510                 `{"firstName":"John","lastName":"Smith","isAlive":true,"age":27,"`,
 511                 `address":{"streetAddress":"`,
 512 -               "314 54th Avenue",
 513 +               "21 2nd Street",
 514                 `","city":"New York","state":"NY","postalCode":"10021-3100"},"pho`,
 515                 `neNumbers":[{"type":"home","number":"212 555-1234"},{"type":"off`,
 516                 ... // 101 identical bytes
 517         }, ""),
 518         BytesB: nil,
 519         BytesC: nil,
 520         ... // 9 identical fields
 521   }
 522 >>> TestDiff/Reporter/BinaryString
 523 <<< TestDiff/Reporter/TripleQuote
 524   cmp_test.MyComposite{
 525         StringA: (
 526                 """
 527                 aaa
 528                 bbb
 529 -               ccc
 530 +               CCC
 531                 ddd
 532                 eee
 533                 ... // 10 identical lines
 534                 ppp
 535                 qqq
 536 -               RRR
 537 -               sss
 538 +               rrr
 539 +               SSS
 540                 ttt
 541                 uuu
 542                 ... // 6 identical lines
 543                 """
 544         ),
 545         StringB: "",
 546         BytesA:  nil,
 547         ... // 11 identical fields
 548   }
 549 >>> TestDiff/Reporter/TripleQuote
 550 <<< TestDiff/Reporter/TripleQuoteSlice
 551   []string{
 552         (
 553                 """
 554                 ... // 23 identical lines
 555                 xxx
 556                 yyy
 557 -               zzz
 558                 """
 559         ),
 560         "aaa\nbbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\nkkk\nlll\nmmm\nnnn\nooo\nppp\n"...,
 561   }
 562 >>> TestDiff/Reporter/TripleQuoteSlice
 563 <<< TestDiff/Reporter/TripleQuoteNamedTypes
 564   cmp_test.MyComposite{
 565         StringA: "",
 566         StringB: (
 567                 """
 568                 aaa
 569                 bbb
 570 -               ccc
 571 +               CCC
 572                 ddd
 573                 eee
 574                 ... // 10 identical lines
 575                 ppp
 576                 qqq
 577 -               RRR
 578 -               sss
 579 +               rrr
 580 +               SSS
 581                 ttt
 582                 uuu
 583                 ... // 5 identical lines
 584                 """
 585         ),
 586         BytesA: nil,
 587         BytesB: nil,
 588         BytesC: cmp_test.MyBytes(
 589                 """
 590                 aaa
 591                 bbb
 592 -               ccc
 593 +               CCC
 594                 ddd
 595                 eee
 596                 ... // 10 identical lines
 597                 ppp
 598                 qqq
 599 -               RRR
 600 -               sss
 601 +               rrr
 602 +               SSS
 603                 ttt
 604                 uuu
 605                 ... // 5 identical lines
 606                 """
 607         ),
 608         IntsA: nil,
 609         IntsB: nil,
 610         ... // 7 identical fields
 611   }
 612 >>> TestDiff/Reporter/TripleQuoteNamedTypes
 613 <<< TestDiff/Reporter/TripleQuoteSliceNamedTypes
 614   []cmp_test.MyString{
 615         (
 616                 """
 617                 ... // 23 identical lines
 618                 xxx
 619                 yyy
 620 -               zzz
 621                 """
 622         ),
 623         "aaa\nbbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\nkkk\nlll\nmmm\nnnn\nooo\nppp\n"...,
 624   }
 625 >>> TestDiff/Reporter/TripleQuoteSliceNamedTypes
 626 <<< TestDiff/Reporter/TripleQuoteEndlines
 627   (
 628         """
 629         aaa
 630         bbb
 631 -       ccc
 632 +       CCC
 633         ddd
 634         eee
 635         ... // 10 identical lines
 636         ppp
 637         qqq
 638 -       RRR
 639 +       rrr
 640         sss
 641         ttt
 642         ... // 4 identical lines
 643         yyy
 644         zzz
 645 -
 646         """
 647   )
 648 >>> TestDiff/Reporter/TripleQuoteEndlines
 649 <<< TestDiff/Reporter/AvoidTripleQuoteAmbiguousQuotes
 650   strings.Join({
 651         "aaa",
 652         "bbb",
 653 -       "ccc",
 654 +       "CCC",
 655         "ddd",
 656         "eee",
 657 -       "fff",
 658 +       `"""`,
 659         "ggg",
 660         "hhh",
 661         ... // 7 identical lines
 662         "ppp",
 663         "qqq",
 664 -       "RRR",
 665 +       "rrr",
 666         "sss",
 667         "ttt",
 668         ... // 7 identical lines
 669   }, "\n")
 670 >>> TestDiff/Reporter/AvoidTripleQuoteAmbiguousQuotes
 671 <<< TestDiff/Reporter/AvoidTripleQuoteAmbiguousEllipsis
 672   strings.Join({
 673         "aaa",
 674         "bbb",
 675 -       "ccc",
 676 -       "...",
 677 +       "CCC",
 678 +       "ddd",
 679         "eee",
 680         "fff",
 681         ... // 9 identical lines
 682         "ppp",
 683         "qqq",
 684 -       "RRR",
 685 +       "rrr",
 686         "sss",
 687         "ttt",
 688         ... // 7 identical lines
 689   }, "\n")
 690 >>> TestDiff/Reporter/AvoidTripleQuoteAmbiguousEllipsis
 691 <<< TestDiff/Reporter/AvoidTripleQuoteNonPrintable
 692   strings.Join({
 693         "aaa",
 694         "bbb",
 695 -       "ccc",
 696 +       "CCC",
 697         "ddd",
 698         "eee",
 699         ... // 7 identical lines
 700         "mmm",
 701         "nnn",
 702 -       "ooo",
 703 +       "o\roo",
 704         "ppp",
 705         "qqq",
 706 -       "RRR",
 707 +       "rrr",
 708         "sss",
 709         "ttt",
 710         ... // 7 identical lines
 711   }, "\n")
 712 >>> TestDiff/Reporter/AvoidTripleQuoteNonPrintable
 713 <<< TestDiff/Reporter/AvoidTripleQuoteIdenticalWhitespace
 714   strings.Join({
 715         "aaa",
 716         "bbb",
 717 -       "ccc",
 718 -       " ddd",
 719 +       "ccc ",
 720 +       "ddd",
 721         "eee",
 722         "fff",
 723         ... // 9 identical lines
 724         "ppp",
 725         "qqq",
 726 -       "RRR",
 727 +       "rrr",
 728         "sss",
 729         "ttt",
 730         ... // 7 identical lines
 731   }, "\n")
 732 >>> TestDiff/Reporter/AvoidTripleQuoteIdenticalWhitespace
 733 <<< TestDiff/Reporter/TripleQuoteStringer
 734   []fmt.Stringer{
 735         s"package main\n\nimport (\n\t\"fmt\"\n)\n\nfunc main() {\n\tfmt.Println(\"Hel"...,
 736 -       (
 737 -               s"""
 738 -               package main
 739 -
 740 -               import (
 741 -                       "fmt"
 742 -                       "math/rand"
 743 -               )
 744 -
 745 -               func main() {
 746 -                       fmt.Println("My favorite number is", rand.Intn(10))
 747 -               }
 748 -               s"""
 749 -       ),
 750 +       (
 751 +               s"""
 752 +               package main
 753 +
 754 +               import (
 755 +                       "fmt"
 756 +                       "math"
 757 +               )
 758 +
 759 +               func main() {
 760 +                       fmt.Printf("Now you have %g problems.\n", math.Sqrt(7))
 761 +               }
 762 +               s"""
 763 +       ),
 764   }
 765 >>> TestDiff/Reporter/TripleQuoteStringer
 766 <<< TestDiff/Reporter/LimitMaximumBytesDiffs
 767   []uint8{
 768 -       0xcd, 0x3d, 0x3d, 0x3d, 0x3d, 0x06, 0x1f, 0xc2, 0xcc, 0xc2, 0x2d, 0x53,                         // -|.====.....-S|
 769 +       0x5c, 0x3d, 0x3d, 0x3d, 0x3d, 0x7c, 0x96, 0xe7, 0x53, 0x42, 0xa0, 0xab,                         // +|\====|..SB..|
 770         0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                                   //  |=====|
 771 -       0x1d, 0xdf, 0x61, 0xae, 0x98, 0x9f, 0x48,                                                       // -|..a...H|
 772 +       0xf0, 0xbd, 0xa5, 0x71, 0xab, 0x17, 0x3b,                                                       // +|...q..;|
 773         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                             //  |======|
 774 -       0xc7, 0xb0, 0xb7,                                                                               // -|...|
 775 +       0xab, 0x50, 0x00,                                                                               // +|.P.|
 776         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                       //  |=======|
 777 -       0xef, 0x3d, 0x3d, 0x3d, 0x3d, 0x3a, 0x5c, 0x94, 0xe6, 0x4a, 0xc7,                               // -|.====:\..J.|
 778 +       0xeb, 0x3d, 0x3d, 0x3d, 0x3d, 0xa5, 0x14, 0xe6, 0x4f, 0x28, 0xe4,                               // +|.====...O(.|
 779         0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                                   //  |=====|
 780 -       0xb4,                                                                                           // -|.|
 781 +       0x28,                                                                                           // +|(|
 782         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                             //  |======|
 783 -       0x0a, 0x0a, 0xf7, 0x94,                                                                         // -|....|
 784 +       0x2f, 0x63, 0x40, 0x3f,                                                                         // +|/c@?|
 785         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                               //  |===========|
 786 -       0xf2, 0x9c, 0xc0, 0x66,                                                                         // -|...f|
 787 +       0xd9, 0x78, 0xed, 0x13,                                                                         // +|.x..|
 788         0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                                   //  |=====|
 789 -       0x34, 0xf6, 0xf1, 0xc3, 0x17, 0x82,                                                             // -|4.....|
 790 +       0x4a, 0xfc, 0x91, 0x38, 0x42, 0x8d,                                                             // +|J..8B.|
 791         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                             //  |======|
 792 -       0x6e, 0x16, 0x60, 0x91, 0x44, 0xc6, 0x06,                                                       // -|n.`.D..|
 793 +       0x61, 0x38, 0x41, 0xeb, 0x73, 0x04, 0xae,                                                       // +|a8A.s..|
 794         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                       //  |=======|
 795 -       0x1c, 0x45, 0x3d, 0x3d, 0x3d, 0x3d, 0x2e,                                                       // -|.E====.|
 796 +       0x07, 0x43, 0x3d, 0x3d, 0x3d, 0x3d, 0x1c,                                                       // +|.C====.|
 797         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                               //  |===========|
 798 -       0xc4, 0x18,                                                                                     // -|..|
 799 +       0x91, 0x22,                                                                                     // +|."|
 800         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                       //  |=======|
 801 -       0x8a, 0x8d, 0x0e, 0x3d, 0x3d, 0x3d, 0x3d, 0x87, 0xb1, 0xa5, 0x8e, 0xc3, 0x3d, 0x3d, 0x3d, 0x3d, // -|...====.....====|
 802 -       0x3d, 0x7a, 0x0f, 0x31, 0xae, 0x55, 0x3d,                                                       // -|=z.1.U=|
 803 +       0x75, 0xd8, 0xbe, 0x3d, 0x3d, 0x3d, 0x3d, 0x73, 0xec, 0x84, 0x35, 0x07, 0x3d, 0x3d, 0x3d, 0x3d, // +|u..====s..5.====|
 804 +       0x3d, 0x3b, 0xab, 0x53, 0x39, 0x74,                                                             // +|=;.S9t|
 805         0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                                   //  |=====|
 806 -       0x47, 0x2c, 0x3d,                                                                               // -|G,=|
 807 +       0x3d, 0x1f, 0x1b,                                                                               // +|=..|
 808         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                                             //  |======|
 809 -       0x35, 0xe7, 0x35, 0xee, 0x82, 0xf4, 0xce, 0x3d, 0x3d, 0x3d, 0x3d, 0x11, 0x72, 0x3d,             // -|5.5....====.r=|
 810 +       0x3d, 0x80, 0xab, 0x2f, 0xed, 0x2b, 0x3a, 0x3b, 0x3d, 0x3d, 0x3d, 0x3d, 0xea, 0x49,             // +|=../.+:;====.I|
 811         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,                                     //  |==========|
 812 -       0xaf, 0x5d, 0x3d,                                                                               // -|.]=|
 813 +       0x3d, 0xab, 0x6c,                                                                               // +|=.l|
 814         ... // 51 identical, 34 removed, and 35 inserted bytes
 815   }
 816 >>> TestDiff/Reporter/LimitMaximumBytesDiffs
 817 <<< TestDiff/Reporter/LimitMaximumStringDiffs
 818   (
 819         """
 820 -       a
 821 +       aa
 822         b
 823 -       c
 824 +       cc
 825         d
 826 -       e
 827 +       ee
 828         f
 829 -       g
 830 +       gg
 831         h
 832 -       i
 833 +       ii
 834         j
 835 -       k
 836 +       kk
 837         l
 838 -       m
 839 +       mm
 840         n
 841 -       o
 842 +       oo
 843         p
 844 -       q
 845 +       qq
 846         r
 847 -       s
 848 +       ss
 849         t
 850 -       u
 851 +       uu
 852         v
 853 -       w
 854 +       ww
 855         x
 856 -       y
 857 +       yy
 858         z
 859 -       A
 860 +       AA
 861         B
 862 -       C
 863 +       CC
 864         D
 865 -       E
 866 +       EE
 867         ... // 12 identical, 10 removed, and 10 inserted lines
 868         """
 869   )
 870 >>> TestDiff/Reporter/LimitMaximumStringDiffs
 871 <<< TestDiff/Reporter/LimitMaximumSliceDiffs
 872   []struct{ S string }{
 873 -       {S: "a"},
 874 +       {S: "aa"},
 875         {S: "b"},
 876 -       {S: "c"},
 877 +       {S: "cc"},
 878         {S: "d"},
 879 -       {S: "e"},
 880 +       {S: "ee"},
 881         {S: "f"},
 882 -       {S: "g"},
 883 +       {S: "gg"},
 884         {S: "h"},
 885 -       {S: "i"},
 886 +       {S: "ii"},
 887         {S: "j"},
 888 -       {S: "k"},
 889 +       {S: "kk"},
 890         {S: "l"},
 891 -       {S: "m"},
 892 +       {S: "mm"},
 893         {S: "n"},
 894 -       {S: "o"},
 895 +       {S: "oo"},
 896         {S: "p"},
 897 -       {S: "q"},
 898 +       {S: "qq"},
 899         {S: "r"},
 900 -       {S: "s"},
 901 +       {S: "ss"},
 902         {S: "t"},
 903 -       {S: "u"},
 904 +       {S: "uu"},
 905         {S: "v"},
 906 -       {S: "w"},
 907 +       {S: "ww"},
 908         {S: "x"},
 909 -       {S: "y"},
 910 +       {S: "yy"},
 911         {S: "z"},
 912 -       {S: "A"},
 913 +       {S: "AA"},
 914         {S: "B"},
 915 -       {S: "C"},
 916 +       {S: "CC"},
 917         {S: "D"},
 918 -       {S: "E"},
 919 +       {S: "EE"},
 920         ... // 12 identical and 10 modified elements
 921   }
 922 >>> TestDiff/Reporter/LimitMaximumSliceDiffs
 923 <<< TestDiff/Reporter/MultilineString
 924   cmp_test.MyComposite{
 925         StringA: (
 926                 """
 927 -               Package cmp determines equality of values.
 928 +               Package cmp determines equality of value.
 929
 930                 This package is intended to be a more powerful and safer alternative to
 931                 ... // 6 identical lines
 932                 For example, an equality function may report floats as equal so long as they
 933                 are within some tolerance of each other.
 934 -
 935 -               • Types that have an Equal method may use that method to determine equality.
 936 -               This allows package authors to determine the equality operation for the types
 937 -               that they define.
 938
 939                 • If no custom equality functions are used and no Equal method is defined,
 940                 ... // 3 identical lines
 941                 by using an Ignore option (see cmpopts.IgnoreUnexported) or explicitly compared
 942                 using the AllowUnexported option.
 943 -
 944                 """
 945         ),
 946         StringB: "",
 947         BytesA:  nil,
 948         ... // 11 identical fields
 949   }
 950 >>> TestDiff/Reporter/MultilineString
 951 <<< TestDiff/Reporter/Slices
 952   cmp_test.MyComposite{
 953         StringA: "",
 954         StringB: "",
 955 -       BytesA:  []uint8{0x01, 0x02, 0x03},
 956 +       BytesA:  nil,
 957 -       BytesB:  []cmp_test.MyByte{0x04, 0x05, 0x06},
 958 +       BytesB:  nil,
 959 -       BytesC:  cmp_test.MyBytes{0x07, 0x08, 0x09},
 960 +       BytesC:  nil,
 961 -       IntsA:   []int8{-1, -2, -3},
 962 +       IntsA:   nil,
 963 -       IntsB:   []cmp_test.MyInt{-4, -5, -6},
 964 +       IntsB:   nil,
 965 -       IntsC:   cmp_test.MyInts{-7, -8, -9},
 966 +       IntsC:   nil,
 967 -       UintsA:  []uint16{1000, 2000, 3000},
 968 +       UintsA:  nil,
 969 -       UintsB:  []cmp_test.MyUint{4000, 5000, 6000},
 970 +       UintsB:  nil,
 971 -       UintsC:  cmp_test.MyUints{7000, 8000, 9000},
 972 +       UintsC:  nil,
 973 -       FloatsA: []float32{1.5, 2.5, 3.5},
 974 +       FloatsA: nil,
 975 -       FloatsB: []cmp_test.MyFloat{4.5, 5.5, 6.5},
 976 +       FloatsB: nil,
 977 -       FloatsC: cmp_test.MyFloats{7.5, 8.5, 9.5},
 978 +       FloatsC: nil,
 979   }
 980 >>> TestDiff/Reporter/Slices
 981 <<< TestDiff/Reporter/EmptySlices
 982   cmp_test.MyComposite{
 983         StringA: "",
 984         StringB: "",
 985 -       BytesA:  []uint8{},
 986 +       BytesA:  nil,
 987 -       BytesB:  []cmp_test.MyByte{},
 988 +       BytesB:  nil,
 989 -       BytesC:  cmp_test.MyBytes{},
 990 +       BytesC:  nil,
 991 -       IntsA:   []int8{},
 992 +       IntsA:   nil,
 993 -       IntsB:   []cmp_test.MyInt{},
 994 +       IntsB:   nil,
 995 -       IntsC:   cmp_test.MyInts{},
 996 +       IntsC:   nil,
 997 -       UintsA:  []uint16{},
 998 +       UintsA:  nil,
 999 -       UintsB:  []cmp_test.MyUint{},
1000 +       UintsB:  nil,
1001 -       UintsC:  cmp_test.MyUints{},
1002 +       UintsC:  nil,
1003 -       FloatsA: []float32{},
1004 +       FloatsA: nil,
1005 -       FloatsB: []cmp_test.MyFloat{},
1006 +       FloatsB: nil,
1007 -       FloatsC: cmp_test.MyFloats{},
1008 +       FloatsC: nil,
1009   }
1010 >>> TestDiff/Reporter/EmptySlices
1011 <<< TestDiff/Reporter/LargeMapKey
1012   map[*[]uint8]int{
1013 -       &⟪0xdeadf00f⟫⟪ptr:0xdeadf00f, len:1048576, cap:1048576⟫{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...}: 0,
1014 +       &⟪0xdeadf00f⟫⟪ptr:0xdeadf00f, len:1048576, cap:1048576⟫{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...}: 0,
1015   }
1016 >>> TestDiff/Reporter/LargeMapKey
1017 <<< TestDiff/EmbeddedStruct/ParentStructA/Inequal
1018   teststructs.ParentStructA{
1019         privateStruct: teststructs.privateStruct{
1020 -               Public:  1,
1021 +               Public:  2,
1022 -               private: 2,
1023 +               private: 3,
1024         },
1025   }
1026 >>> TestDiff/EmbeddedStruct/ParentStructA/Inequal
1027 <<< TestDiff/EmbeddedStruct/ParentStructB/Inequal
1028   teststructs.ParentStructB{
1029         PublicStruct: teststructs.PublicStruct{
1030 -               Public:  1,
1031 +               Public:  2,
1032 -               private: 2,
1033 +               private: 3,
1034         },
1035   }
1036 >>> TestDiff/EmbeddedStruct/ParentStructB/Inequal
1037 <<< TestDiff/EmbeddedStruct/ParentStructC/Inequal
1038   teststructs.ParentStructC{
1039         privateStruct: teststructs.privateStruct{
1040 -               Public:  1,
1041 +               Public:  2,
1042 -               private: 2,
1043 +               private: 3,
1044         },
1045 -       Public:  3,
1046 +       Public:  4,
1047 -       private: 4,
1048 +       private: 5,
1049   }
1050 >>> TestDiff/EmbeddedStruct/ParentStructC/Inequal
1051 <<< TestDiff/EmbeddedStruct/ParentStructD/Inequal
1052   teststructs.ParentStructD{
1053         PublicStruct: teststructs.PublicStruct{
1054 -               Public:  1,
1055 +               Public:  2,
1056 -               private: 2,
1057 +               private: 3,
1058         },
1059 -       Public:  3,
1060 +       Public:  4,
1061 -       private: 4,
1062 +       private: 5,
1063   }
1064 >>> TestDiff/EmbeddedStruct/ParentStructD/Inequal
1065 <<< TestDiff/EmbeddedStruct/ParentStructE/Inequal
1066   teststructs.ParentStructE{
1067         privateStruct: teststructs.privateStruct{
1068 -               Public:  1,
1069 +               Public:  2,
1070 -               private: 2,
1071 +               private: 3,
1072         },
1073         PublicStruct: teststructs.PublicStruct{
1074 -               Public:  3,
1075 +               Public:  4,
1076 -               private: 4,
1077 +               private: 5,
1078         },
1079   }
1080 >>> TestDiff/EmbeddedStruct/ParentStructE/Inequal
1081 <<< TestDiff/EmbeddedStruct/ParentStructF/Inequal
1082   teststructs.ParentStructF{
1083         privateStruct: teststructs.privateStruct{
1084 -               Public:  1,
1085 +               Public:  2,
1086 -               private: 2,
1087 +               private: 3,
1088         },
1089         PublicStruct: teststructs.PublicStruct{
1090 -               Public:  3,
1091 +               Public:  4,
1092 -               private: 4,
1093 +               private: 5,
1094         },
1095 -       Public:  5,
1096 +       Public:  6,
1097 -       private: 6,
1098 +       private: 7,
1099   }
1100 >>> TestDiff/EmbeddedStruct/ParentStructF/Inequal
1101 <<< TestDiff/EmbeddedStruct/ParentStructG/Inequal
1102   &teststructs.ParentStructG{
1103         privateStruct: &teststructs.privateStruct{
1104 -               Public:  1,
1105 +               Public:  2,
1106 -               private: 2,
1107 +               private: 3,
1108         },
1109   }
1110 >>> TestDiff/EmbeddedStruct/ParentStructG/Inequal
1111 <<< TestDiff/EmbeddedStruct/ParentStructH/Inequal
1112   &teststructs.ParentStructH{
1113         PublicStruct: &teststructs.PublicStruct{
1114 -               Public:  1,
1115 +               Public:  2,
1116 -               private: 2,
1117 +               private: 3,
1118         },
1119   }
1120 >>> TestDiff/EmbeddedStruct/ParentStructH/Inequal
1121 <<< TestDiff/EmbeddedStruct/ParentStructI/Inequal
1122   &teststructs.ParentStructI{
1123         privateStruct: &teststructs.privateStruct{
1124 -               Public:  1,
1125 +               Public:  2,
1126 -               private: 2,
1127 +               private: 3,
1128         },
1129         PublicStruct: &teststructs.PublicStruct{
1130 -               Public:  3,
1131 +               Public:  4,
1132 -               private: 4,
1133 +               private: 5,
1134         },
1135   }
1136 >>> TestDiff/EmbeddedStruct/ParentStructI/Inequal
1137 <<< TestDiff/EmbeddedStruct/ParentStructJ/Inequal
1138   &teststructs.ParentStructJ{
1139         privateStruct: &teststructs.privateStruct{
1140 -               Public:  1,
1141 +               Public:  2,
1142 -               private: 2,
1143 +               private: 3,
1144         },
1145         PublicStruct: &teststructs.PublicStruct{
1146 -               Public:  3,
1147 +               Public:  4,
1148 -               private: 4,
1149 +               private: 5,
1150         },
1151         Public: teststructs.PublicStruct{
1152 -               Public:  7,
1153 +               Public:  8,
1154 -               private: 8,
1155 +               private: 9,
1156         },
1157         private: teststructs.privateStruct{
1158 -               Public:  5,
1159 +               Public:  6,
1160 -               private: 6,
1161 +               private: 7,
1162         },
1163   }
1164 >>> TestDiff/EmbeddedStruct/ParentStructJ/Inequal
1165 <<< TestDiff/EqualMethod/StructB/ValueInequal
1166   teststructs.StructB{
1167 -       X: "NotEqual",
1168 +       X: "not_equal",
1169   }
1170 >>> TestDiff/EqualMethod/StructB/ValueInequal
1171 <<< TestDiff/EqualMethod/StructD/ValueInequal
1172   teststructs.StructD{
1173 -       X: "NotEqual",
1174 +       X: "not_equal",
1175   }
1176 >>> TestDiff/EqualMethod/StructD/ValueInequal
1177 <<< TestDiff/EqualMethod/StructE/ValueInequal
1178   teststructs.StructE{
1179 -       X: "NotEqual",
1180 +       X: "not_equal",
1181   }
1182 >>> TestDiff/EqualMethod/StructE/ValueInequal
1183 <<< TestDiff/EqualMethod/StructF/ValueInequal
1184   teststructs.StructF{
1185 -       X: "NotEqual",
1186 +       X: "not_equal",
1187   }
1188 >>> TestDiff/EqualMethod/StructF/ValueInequal
1189 <<< TestDiff/EqualMethod/StructA1/ValueInequal
1190   teststructs.StructA1{
1191         StructA: {X: "NotEqual"},
1192 -       X:       "NotEqual",
1193 +       X:       "not_equal",
1194   }
1195 >>> TestDiff/EqualMethod/StructA1/ValueInequal
1196 <<< TestDiff/EqualMethod/StructA1/PointerInequal
1197   &teststructs.StructA1{
1198         StructA: {X: "NotEqual"},
1199 -       X:       "NotEqual",
1200 +       X:       "not_equal",
1201   }
1202 >>> TestDiff/EqualMethod/StructA1/PointerInequal
1203 <<< TestDiff/EqualMethod/StructB1/ValueInequal
1204   teststructs.StructB1{
1205         StructB: Inverse(Addr, &teststructs.StructB{X: "NotEqual"}),
1206 -       X:       "NotEqual",
1207 +       X:       "not_equal",
1208   }
1209 >>> TestDiff/EqualMethod/StructB1/ValueInequal
1210 <<< TestDiff/EqualMethod/StructB1/PointerInequal
1211   &teststructs.StructB1{
1212         StructB: Inverse(Addr, &teststructs.StructB{X: "NotEqual"}),
1213 -       X:       "NotEqual",
1214 +       X:       "not_equal",
1215   }
1216 >>> TestDiff/EqualMethod/StructB1/PointerInequal
1217 <<< TestDiff/EqualMethod/StructD1/ValueInequal
1218   teststructs.StructD1{
1219 -       StructD: teststructs.StructD{X: "NotEqual"},
1220 +       StructD: teststructs.StructD{X: "not_equal"},
1221 -       X:       "NotEqual",
1222 +       X:       "not_equal",
1223   }
1224 >>> TestDiff/EqualMethod/StructD1/ValueInequal
1225 <<< TestDiff/EqualMethod/StructE1/ValueInequal
1226   teststructs.StructE1{
1227 -       StructE: teststructs.StructE{X: "NotEqual"},
1228 +       StructE: teststructs.StructE{X: "not_equal"},
1229 -       X:       "NotEqual",
1230 +       X:       "not_equal",
1231   }
1232 >>> TestDiff/EqualMethod/StructE1/ValueInequal
1233 <<< TestDiff/EqualMethod/StructF1/ValueInequal
1234   teststructs.StructF1{
1235 -       StructF: teststructs.StructF{X: "NotEqual"},
1236 +       StructF: teststructs.StructF{X: "not_equal"},
1237 -       X:       "NotEqual",
1238 +       X:       "not_equal",
1239   }
1240 >>> TestDiff/EqualMethod/StructF1/ValueInequal
1241 <<< TestDiff/EqualMethod/StructA2/ValueInequal
1242   teststructs.StructA2{
1243         StructA: &{X: "NotEqual"},
1244 -       X:       "NotEqual",
1245 +       X:       "not_equal",
1246   }
1247 >>> TestDiff/EqualMethod/StructA2/ValueInequal
1248 <<< TestDiff/EqualMethod/StructA2/PointerInequal
1249   &teststructs.StructA2{
1250         StructA: &{X: "NotEqual"},
1251 -       X:       "NotEqual",
1252 +       X:       "not_equal",
1253   }
1254 >>> TestDiff/EqualMethod/StructA2/PointerInequal
1255 <<< TestDiff/EqualMethod/StructB2/ValueInequal
1256   teststructs.StructB2{
1257         StructB: &{X: "NotEqual"},
1258 -       X:       "NotEqual",
1259 +       X:       "not_equal",
1260   }
1261 >>> TestDiff/EqualMethod/StructB2/ValueInequal
1262 <<< TestDiff/EqualMethod/StructB2/PointerInequal
1263   &teststructs.StructB2{
1264         StructB: &{X: "NotEqual"},
1265 -       X:       "NotEqual",
1266 +       X:       "not_equal",
1267   }
1268 >>> TestDiff/EqualMethod/StructB2/PointerInequal
1269 <<< TestDiff/EqualMethod/StructNo/Inequal
1270   teststructs.StructNo{
1271 -       X: "NotEqual",
1272 +       X: "not_equal",
1273   }
1274 >>> TestDiff/EqualMethod/StructNo/Inequal
1275 <<< TestDiff/Cycle/PointersInequal
1276   &&⟪ref#0⟫cmp_test.P(
1277 -       &⟪ref#0⟫(...),
1278 +       &&⟪ref#0⟫(...),
1279   )
1280 >>> TestDiff/Cycle/PointersInequal
1281 <<< TestDiff/Cycle/SlicesInequal
1282   cmp_test.S{
1283 -       ⟪ref#0⟫{⟪ref#0⟫(...)},
1284 +       ⟪ref#1⟫{{⟪ref#1⟫(...)}},
1285   }
1286 >>> TestDiff/Cycle/SlicesInequal
1287 <<< TestDiff/Cycle/MapsInequal
1288   cmp_test.M⟪ref#0⟫{
1289 -       0: ⟪ref#0⟫(...),
1290 +       0: {0: ⟪ref#0⟫(...)},
1291   }
1292 >>> TestDiff/Cycle/MapsInequal
1293 <<< TestDiff/Cycle/GraphInequalZeroed
1294   map[string]*cmp_test.CycleAlpha{
1295         "Bar": &⟪ref#0⟫{
1296                 Name: "Bar",
1297                 Bravos: map[string]*cmp_test.CycleBravo{
1298                         "BarBuzzBravo": &⟪ref#1⟫{
1299 -                               ID:   102,
1300 +                               ID:   0,
1301                                 Name: "BarBuzzBravo",
1302                                 Mods: 2,
1303                                 Alphas: map[string]*cmp_test.CycleAlpha{
1304                                         "Bar": &⟪ref#0⟫(...),
1305                                         "Buzz": &⟪ref#2⟫{
1306                                                 Name: "Buzz",
1307                                                 Bravos: map[string]*cmp_test.CycleBravo{
1308                                                         "BarBuzzBravo": &⟪ref#1⟫(...),
1309                                                         "BuzzBarBravo": &⟪ref#3⟫{
1310 -                                                               ID:     103,
1311 +                                                               ID:     0,
1312                                                                 Name:   "BuzzBarBravo",
1313                                                                 Mods:   0,
1314                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1315                                                         },
1316                                                 },
1317                                         },
1318                                 },
1319                         },
1320                         "BuzzBarBravo": &⟪ref#3⟫{
1321 -                               ID:   103,
1322 +                               ID:   0,
1323                                 Name: "BuzzBarBravo",
1324                                 Mods: 0,
1325                                 Alphas: map[string]*cmp_test.CycleAlpha{
1326                                         "Bar": &⟪ref#0⟫(...),
1327                                         "Buzz": &⟪ref#2⟫{
1328                                                 Name: "Buzz",
1329                                                 Bravos: map[string]*cmp_test.CycleBravo{
1330                                                         "BarBuzzBravo": &⟪ref#1⟫{
1331 -                                                               ID:     102,
1332 +                                                               ID:     0,
1333                                                                 Name:   "BarBuzzBravo",
1334                                                                 Mods:   2,
1335                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1336                                                         },
1337                                                         "BuzzBarBravo": &⟪ref#3⟫(...),
1338                                                 },
1339                                         },
1340                                 },
1341                         },
1342                 },
1343         },
1344         "Buzz": &⟪ref#2⟫{
1345                 Name: "Buzz",
1346                 Bravos: map[string]*cmp_test.CycleBravo{
1347                         "BarBuzzBravo": &⟪ref#1⟫{
1348 -                               ID:   102,
1349 +                               ID:   0,
1350                                 Name: "BarBuzzBravo",
1351                                 Mods: 2,
1352                                 Alphas: map[string]*cmp_test.CycleAlpha{
1353                                         "Bar": &⟪ref#0⟫{
1354                                                 Name: "Bar",
1355                                                 Bravos: map[string]*cmp_test.CycleBravo{
1356                                                         "BarBuzzBravo": &⟪ref#1⟫(...),
1357                                                         "BuzzBarBravo": &⟪ref#3⟫{
1358 -                                                               ID:     103,
1359 +                                                               ID:     0,
1360                                                                 Name:   "BuzzBarBravo",
1361                                                                 Mods:   0,
1362                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1363                                                         },
1364                                                 },
1365                                         },
1366                                         "Buzz": &⟪ref#2⟫(...),
1367                                 },
1368                         },
1369                         "BuzzBarBravo": &⟪ref#3⟫{
1370 -                               ID:   103,
1371 +                               ID:   0,
1372                                 Name: "BuzzBarBravo",
1373                                 Mods: 0,
1374                                 Alphas: map[string]*cmp_test.CycleAlpha{
1375                                         "Bar": &⟪ref#0⟫{
1376                                                 Name: "Bar",
1377                                                 Bravos: map[string]*cmp_test.CycleBravo{
1378                                                         "BarBuzzBravo": &⟪ref#1⟫{
1379 -                                                               ID:     102,
1380 +                                                               ID:     0,
1381                                                                 Name:   "BarBuzzBravo",
1382                                                                 Mods:   2,
1383                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1384                                                         },
1385                                                         "BuzzBarBravo": &⟪ref#3⟫(...),
1386                                                 },
1387                                         },
1388                                         "Buzz": &⟪ref#2⟫(...),
1389                                 },
1390                         },
1391                 },
1392         },
1393         "Foo": &⟪ref#4⟫{
1394                 Name: "Foo",
1395                 Bravos: map[string]*cmp_test.CycleBravo{
1396                         "FooBravo": &{
1397 -                               ID:     101,
1398 +                               ID:     0,
1399                                 Name:   "FooBravo",
1400                                 Mods:   100,
1401                                 Alphas: {"Foo": &⟪ref#4⟫(...)},
1402                         },
1403                 },
1404         },
1405   }
1406 >>> TestDiff/Cycle/GraphInequalZeroed
1407 <<< TestDiff/Cycle/GraphInequalStruct
1408   map[string]*cmp_test.CycleAlpha{
1409         "Bar": &⟪ref#0⟫{
1410                 Name: "Bar",
1411                 Bravos: map[string]*cmp_test.CycleBravo{
1412                         "BarBuzzBravo": &⟪ref#1⟫{
1413                                 ID:   102,
1414                                 Name: "BarBuzzBravo",
1415                                 Mods: 2,
1416                                 Alphas: map[string]*cmp_test.CycleAlpha{
1417                                         "Bar": &⟪ref#0⟫(...),
1418                                         "Buzz": &⟪ref#2⟫{
1419                                                 Name: "Buzz",
1420                                                 Bravos: map[string]*cmp_test.CycleBravo{
1421                                                         "BarBuzzBravo": &⟪ref#1⟫(...),
1422                                                         "BuzzBarBravo": &⟪ref#3⟫{
1423                                                                 ID:     103,
1424                                                                 Name:   "BuzzBarBravo",
1425                                                                 Mods:   0,
1426 -                                                               Alphas: nil,
1427 +                                                               Alphas: map[string]*cmp_test.CycleAlpha{"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1428                                                         },
1429                                                 },
1430                                         },
1431                                 },
1432                         },
1433                         "BuzzBarBravo": &⟪ref#3⟫{
1434                                 ID:   103,
1435                                 Name: "BuzzBarBravo",
1436                                 Mods: 0,
1437                                 Alphas: map[string]*cmp_test.CycleAlpha{
1438                                         "Bar": &⟪ref#0⟫(...),
1439                                         "Buzz": &⟪ref#2⟫{
1440                                                 Name: "Buzz",
1441                                                 Bravos: map[string]*cmp_test.CycleBravo{
1442                                                         "BarBuzzBravo": &⟪ref#1⟫{ID: 102, Name: "BarBuzzBravo", Mods: 2, Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}},
1443 -                                                       "BuzzBarBravo": &{ID: 103, Name: "BuzzBarBravo"},
1444 +                                                       "BuzzBarBravo": &⟪ref#3⟫(...),
1445                                                 },
1446                                         },
1447                                 },
1448                         },
1449                 },
1450         },
1451         "Buzz": &⟪ref#2⟫{
1452                 Name: "Buzz",
1453                 Bravos: map[string]*cmp_test.CycleBravo{
1454                         "BarBuzzBravo": &⟪ref#1⟫{ID: 102, Name: "BarBuzzBravo", Mods: 2, Alphas: {"Bar": &⟪ref#0⟫{Name: "Bar", Bravos: {"BarBuzzBravo": &⟪ref#1⟫(...), "BuzzBarBravo": &⟪ref#3⟫{ID: 103, Name: "BuzzBarBravo", Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}}}}, "Buzz": &⟪ref#2⟫(...)}},
1455                         "BuzzBarBravo": &⟪ref#3⟫{
1456                                 ID:     103,
1457                                 Name:   "BuzzBarBravo",
1458                                 Mods:   0,
1459 -                               Alphas: nil,
1460 +                               Alphas: map[string]*cmp_test.CycleAlpha{
1461 +                                       "Bar": &⟪ref#0⟫{
1462 +                                               Name:   "Bar",
1463 +                                               Bravos: map[string]*cmp_test.CycleBravo{"BarBuzzBravo": &⟪ref#1⟫{...}, "BuzzBarBravo": &⟪ref#3⟫(...)},
1464 +                                       },
1465 +                                       "Buzz": &⟪ref#2⟫(...),
1466 +                               },
1467                         },
1468                 },
1469         },
1470         "Foo": &⟪ref#4⟫{Name: "Foo", Bravos: {"FooBravo": &{ID: 101, Name: "FooBravo", Mods: 100, Alphas: {"Foo": &⟪ref#4⟫(...)}}}},
1471   }
1472 >>> TestDiff/Cycle/GraphInequalStruct
1473 <<< TestDiff/Project1/ProtoInequal
1474   teststructs.Eagle{
1475         ... // 4 identical fields
1476         Dreamers: nil,
1477         Prong:    0,
1478         Slaps: []teststructs.Slap{
1479                 ... // 2 identical elements
1480                 {},
1481                 {},
1482                 {
1483                         Name:     "",
1484                         Desc:     "",
1485                         DescLong: "",
1486 -                       Args:     s"metadata",
1487 +                       Args:     s"metadata2",
1488                         Tense:    0,
1489                         Interval: 0,
1490                         ... // 3 identical fields
1491                 },
1492         },
1493         StateGoverner: "",
1494         PrankRating:   "",
1495         ... // 2 identical fields
1496   }
1497 >>> TestDiff/Project1/ProtoInequal
1498 <<< TestDiff/Project1/Inequal
1499   teststructs.Eagle{
1500         ... // 2 identical fields
1501         Desc:     "some description",
1502         DescLong: "",
1503         Dreamers: []teststructs.Dreamer{
1504                 {},
1505                 {
1506                         ... // 4 identical fields
1507                         ContSlaps:         nil,
1508                         ContSlapsInterval: 0,
1509                         Animal: []interface{}{
1510                                 teststructs.Goat{
1511                                         Target:     "corporation",
1512                                         Slaps:      nil,
1513                                         FunnyPrank: "",
1514                                         Immutable: &teststructs.GoatImmutable{
1515 -                                               ID:      "southbay2",
1516 +                                               ID:      "southbay",
1517 -                                               State:   &6,
1518 +                                               State:   &5,
1519                                                 Started: s"2009-11-10 23:00:00 +0000 UTC",
1520                                                 Stopped: s"0001-01-01 00:00:00 +0000 UTC",
1521                                                 ... // 1 ignored and 1 identical fields
1522                                         },
1523                                 },
1524                                 teststructs.Donkey{},
1525                         },
1526                         Ornamental: false,
1527                         Amoeba:     53,
1528                         ... // 5 identical fields
1529                 },
1530         },
1531         Prong: 0,
1532         Slaps: []teststructs.Slap{
1533                 {
1534                         ... // 6 identical fields
1535                         Homeland:   0,
1536                         FunnyPrank: "",
1537                         Immutable: &teststructs.SlapImmutable{
1538                                 ID:          "immutableSlap",
1539                                 Out:         nil,
1540 -                               MildSlap:    false,
1541 +                               MildSlap:    true,
1542                                 PrettyPrint: "",
1543                                 State:       nil,
1544                                 Started:     s"2009-11-10 23:00:00 +0000 UTC",
1545                                 Stopped:     s"0001-01-01 00:00:00 +0000 UTC",
1546                                 LastUpdate:  s"0001-01-01 00:00:00 +0000 UTC",
1547                                 LoveRadius: &teststructs.LoveRadius{
1548                                         Summer: &teststructs.SummerLove{
1549                                                 Summary: &teststructs.SummerLoveSummary{
1550                                                         Devices: []string{
1551                                                                 "foo",
1552 -                                                               "bar",
1553 -                                                               "baz",
1554                                                         },
1555                                                         ChangeType: {1, 2, 3},
1556                                                         ... // 1 ignored field
1557                                                 },
1558                                                 ... // 1 ignored field
1559                                         },
1560                                         ... // 1 ignored field
1561                                 },
1562                                 ... // 1 ignored field
1563                         },
1564                 },
1565         },
1566         StateGoverner: "",
1567         PrankRating:   "",
1568         ... // 2 identical fields
1569   }
1570 >>> TestDiff/Project1/Inequal
1571 <<< TestDiff/Project2/InequalOrder
1572   teststructs.GermBatch{
1573         DirtyGerms: map[int32][]*testprotos.Germ{
1574                 17: {s"germ1"},
1575                 18: {
1576 -                       s"germ2",
1577                         s"germ3",
1578                         s"germ4",
1579 +                       s"germ2",
1580                 },
1581         },
1582         CleanGerms: nil,
1583         GermMap:    {13: s"germ13", 21: s"germ21"},
1584         ... // 7 identical fields
1585   }
1586 >>> TestDiff/Project2/InequalOrder
1587 <<< TestDiff/Project2/Inequal
1588   teststructs.GermBatch{
1589         DirtyGerms: map[int32][]*testprotos.Germ{
1590 +               17: {s"germ1"},
1591                 18: Inverse(Sort, []*testprotos.Germ{
1592                         s"germ2",
1593                         s"germ3",
1594 -                       s"germ4",
1595                 }),
1596         },
1597         CleanGerms: nil,
1598         GermMap:    {13: s"germ13", 21: s"germ21"},
1599         DishMap: map[int32]*teststructs.Dish{
1600                 0: &{err: e"EOF"},
1601 -               1: nil,
1602 +               1: &{err: e"unexpected EOF"},
1603                 2: &{pb: s"dish"},
1604         },
1605         HasPreviousResult: true,
1606         DirtyID:           10,
1607         CleanID:           0,
1608 -       GermStrain:        421,
1609 +       GermStrain:        22,
1610         TotalDirtyGerms:   0,
1611         InfectedAt:        s"2009-11-10 23:00:00 +0000 UTC",
1612   }
1613 >>> TestDiff/Project2/Inequal
1614 <<< TestDiff/Project3/Inequal
1615   teststructs.Dirt{
1616 -       table:   &teststructs.MockTable{state: []string{"a", "c"}},
1617 +       table:   &teststructs.MockTable{state: []string{"a", "b", "c"}},
1618         ts:      12345,
1619 -       Discord: 554,
1620 +       Discord: 500,
1621 -       Proto:   testprotos.Dirt(Inverse(λ, s"blah")),
1622 +       Proto:   testprotos.Dirt(Inverse(λ, s"proto")),
1623         wizard: map[string]*testprotos.Wizard{
1624 -               "albus": s"dumbledore",
1625 -               "harry": s"potter",
1626 +               "harry": s"otter",
1627         },
1628         sadistic: nil,
1629         lastTime: 54321,
1630         ... // 1 ignored field
1631   }
1632 >>> TestDiff/Project3/Inequal
1633 <<< TestDiff/Project4/Inequal
1634   teststructs.Cartel{
1635         Headquarter: teststructs.Headquarter{
1636                 id:       5,
1637                 location: "moon",
1638                 subDivisions: []string{
1639 -                       "alpha",
1640                         "bravo",
1641                         "charlie",
1642                 },
1643                 incorporatedDate: s"0001-01-01 00:00:00 +0000 UTC",
1644                 metaData:         s"metadata",
1645                 privateMessage:   nil,
1646                 publicMessage: []uint8{
1647                         0x01,
1648                         0x02,
1649 -                       0x03,
1650 +                       0x04,
1651 -                       0x04,
1652 +                       0x03,
1653                         0x05,
1654                 },
1655                 horseBack: "abcdef",
1656                 rattle:    "",
1657                 ... // 5 identical fields
1658         },
1659         source:        "mars",
1660         creationDate:  s"0001-01-01 00:00:00 +0000 UTC",
1661         boss:          "al capone",
1662         lastCrimeDate: s"0001-01-01 00:00:00 +0000 UTC",
1663         poisons: []*teststructs.Poison{
1664                 &{
1665 -                       poisonType:   1,
1666 +                       poisonType:   5,
1667                         expiration:   s"2009-11-10 23:00:00 +0000 UTC",
1668                         manufacturer: "acme",
1669                         potency:      0,
1670                 },
1671 -               &{poisonType: 2, manufacturer: "acme2"},
1672         },
1673   }
1674 >>> TestDiff/Project4/Inequal