.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/google/go-cmp@v0.5.1/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/EmbeddedStruct/ParentStructA/Inequal
1012   teststructs.ParentStructA{
1013         privateStruct: teststructs.privateStruct{
1014 -               Public:  1,
1015 +               Public:  2,
1016 -               private: 2,
1017 +               private: 3,
1018         },
1019   }
1020 >>> TestDiff/EmbeddedStruct/ParentStructA/Inequal
1021 <<< TestDiff/EmbeddedStruct/ParentStructB/Inequal
1022   teststructs.ParentStructB{
1023         PublicStruct: teststructs.PublicStruct{
1024 -               Public:  1,
1025 +               Public:  2,
1026 -               private: 2,
1027 +               private: 3,
1028         },
1029   }
1030 >>> TestDiff/EmbeddedStruct/ParentStructB/Inequal
1031 <<< TestDiff/EmbeddedStruct/ParentStructC/Inequal
1032   teststructs.ParentStructC{
1033         privateStruct: teststructs.privateStruct{
1034 -               Public:  1,
1035 +               Public:  2,
1036 -               private: 2,
1037 +               private: 3,
1038         },
1039 -       Public:  3,
1040 +       Public:  4,
1041 -       private: 4,
1042 +       private: 5,
1043   }
1044 >>> TestDiff/EmbeddedStruct/ParentStructC/Inequal
1045 <<< TestDiff/EmbeddedStruct/ParentStructD/Inequal
1046   teststructs.ParentStructD{
1047         PublicStruct: teststructs.PublicStruct{
1048 -               Public:  1,
1049 +               Public:  2,
1050 -               private: 2,
1051 +               private: 3,
1052         },
1053 -       Public:  3,
1054 +       Public:  4,
1055 -       private: 4,
1056 +       private: 5,
1057   }
1058 >>> TestDiff/EmbeddedStruct/ParentStructD/Inequal
1059 <<< TestDiff/EmbeddedStruct/ParentStructE/Inequal
1060   teststructs.ParentStructE{
1061         privateStruct: teststructs.privateStruct{
1062 -               Public:  1,
1063 +               Public:  2,
1064 -               private: 2,
1065 +               private: 3,
1066         },
1067         PublicStruct: teststructs.PublicStruct{
1068 -               Public:  3,
1069 +               Public:  4,
1070 -               private: 4,
1071 +               private: 5,
1072         },
1073   }
1074 >>> TestDiff/EmbeddedStruct/ParentStructE/Inequal
1075 <<< TestDiff/EmbeddedStruct/ParentStructF/Inequal
1076   teststructs.ParentStructF{
1077         privateStruct: teststructs.privateStruct{
1078 -               Public:  1,
1079 +               Public:  2,
1080 -               private: 2,
1081 +               private: 3,
1082         },
1083         PublicStruct: teststructs.PublicStruct{
1084 -               Public:  3,
1085 +               Public:  4,
1086 -               private: 4,
1087 +               private: 5,
1088         },
1089 -       Public:  5,
1090 +       Public:  6,
1091 -       private: 6,
1092 +       private: 7,
1093   }
1094 >>> TestDiff/EmbeddedStruct/ParentStructF/Inequal
1095 <<< TestDiff/EmbeddedStruct/ParentStructG/Inequal
1096   &teststructs.ParentStructG{
1097         privateStruct: &teststructs.privateStruct{
1098 -               Public:  1,
1099 +               Public:  2,
1100 -               private: 2,
1101 +               private: 3,
1102         },
1103   }
1104 >>> TestDiff/EmbeddedStruct/ParentStructG/Inequal
1105 <<< TestDiff/EmbeddedStruct/ParentStructH/Inequal
1106   &teststructs.ParentStructH{
1107         PublicStruct: &teststructs.PublicStruct{
1108 -               Public:  1,
1109 +               Public:  2,
1110 -               private: 2,
1111 +               private: 3,
1112         },
1113   }
1114 >>> TestDiff/EmbeddedStruct/ParentStructH/Inequal
1115 <<< TestDiff/EmbeddedStruct/ParentStructI/Inequal
1116   &teststructs.ParentStructI{
1117         privateStruct: &teststructs.privateStruct{
1118 -               Public:  1,
1119 +               Public:  2,
1120 -               private: 2,
1121 +               private: 3,
1122         },
1123         PublicStruct: &teststructs.PublicStruct{
1124 -               Public:  3,
1125 +               Public:  4,
1126 -               private: 4,
1127 +               private: 5,
1128         },
1129   }
1130 >>> TestDiff/EmbeddedStruct/ParentStructI/Inequal
1131 <<< TestDiff/EmbeddedStruct/ParentStructJ/Inequal
1132   &teststructs.ParentStructJ{
1133         privateStruct: &teststructs.privateStruct{
1134 -               Public:  1,
1135 +               Public:  2,
1136 -               private: 2,
1137 +               private: 3,
1138         },
1139         PublicStruct: &teststructs.PublicStruct{
1140 -               Public:  3,
1141 +               Public:  4,
1142 -               private: 4,
1143 +               private: 5,
1144         },
1145         Public: teststructs.PublicStruct{
1146 -               Public:  7,
1147 +               Public:  8,
1148 -               private: 8,
1149 +               private: 9,
1150         },
1151         private: teststructs.privateStruct{
1152 -               Public:  5,
1153 +               Public:  6,
1154 -               private: 6,
1155 +               private: 7,
1156         },
1157   }
1158 >>> TestDiff/EmbeddedStruct/ParentStructJ/Inequal
1159 <<< TestDiff/EqualMethod/StructB/ValueInequal
1160   teststructs.StructB{
1161 -       X: "NotEqual",
1162 +       X: "not_equal",
1163   }
1164 >>> TestDiff/EqualMethod/StructB/ValueInequal
1165 <<< TestDiff/EqualMethod/StructD/ValueInequal
1166   teststructs.StructD{
1167 -       X: "NotEqual",
1168 +       X: "not_equal",
1169   }
1170 >>> TestDiff/EqualMethod/StructD/ValueInequal
1171 <<< TestDiff/EqualMethod/StructE/ValueInequal
1172   teststructs.StructE{
1173 -       X: "NotEqual",
1174 +       X: "not_equal",
1175   }
1176 >>> TestDiff/EqualMethod/StructE/ValueInequal
1177 <<< TestDiff/EqualMethod/StructF/ValueInequal
1178   teststructs.StructF{
1179 -       X: "NotEqual",
1180 +       X: "not_equal",
1181   }
1182 >>> TestDiff/EqualMethod/StructF/ValueInequal
1183 <<< TestDiff/EqualMethod/StructA1/ValueInequal
1184   teststructs.StructA1{
1185         StructA: {X: "NotEqual"},
1186 -       X:       "NotEqual",
1187 +       X:       "not_equal",
1188   }
1189 >>> TestDiff/EqualMethod/StructA1/ValueInequal
1190 <<< TestDiff/EqualMethod/StructA1/PointerInequal
1191   &teststructs.StructA1{
1192         StructA: {X: "NotEqual"},
1193 -       X:       "NotEqual",
1194 +       X:       "not_equal",
1195   }
1196 >>> TestDiff/EqualMethod/StructA1/PointerInequal
1197 <<< TestDiff/EqualMethod/StructB1/ValueInequal
1198   teststructs.StructB1{
1199         StructB: Inverse(Addr, &teststructs.StructB{X: "NotEqual"}),
1200 -       X:       "NotEqual",
1201 +       X:       "not_equal",
1202   }
1203 >>> TestDiff/EqualMethod/StructB1/ValueInequal
1204 <<< TestDiff/EqualMethod/StructB1/PointerInequal
1205   &teststructs.StructB1{
1206         StructB: Inverse(Addr, &teststructs.StructB{X: "NotEqual"}),
1207 -       X:       "NotEqual",
1208 +       X:       "not_equal",
1209   }
1210 >>> TestDiff/EqualMethod/StructB1/PointerInequal
1211 <<< TestDiff/EqualMethod/StructD1/ValueInequal
1212   teststructs.StructD1{
1213 -       StructD: teststructs.StructD{X: "NotEqual"},
1214 +       StructD: teststructs.StructD{X: "not_equal"},
1215 -       X:       "NotEqual",
1216 +       X:       "not_equal",
1217   }
1218 >>> TestDiff/EqualMethod/StructD1/ValueInequal
1219 <<< TestDiff/EqualMethod/StructE1/ValueInequal
1220   teststructs.StructE1{
1221 -       StructE: teststructs.StructE{X: "NotEqual"},
1222 +       StructE: teststructs.StructE{X: "not_equal"},
1223 -       X:       "NotEqual",
1224 +       X:       "not_equal",
1225   }
1226 >>> TestDiff/EqualMethod/StructE1/ValueInequal
1227 <<< TestDiff/EqualMethod/StructF1/ValueInequal
1228   teststructs.StructF1{
1229 -       StructF: teststructs.StructF{X: "NotEqual"},
1230 +       StructF: teststructs.StructF{X: "not_equal"},
1231 -       X:       "NotEqual",
1232 +       X:       "not_equal",
1233   }
1234 >>> TestDiff/EqualMethod/StructF1/ValueInequal
1235 <<< TestDiff/EqualMethod/StructA2/ValueInequal
1236   teststructs.StructA2{
1237         StructA: &{X: "NotEqual"},
1238 -       X:       "NotEqual",
1239 +       X:       "not_equal",
1240   }
1241 >>> TestDiff/EqualMethod/StructA2/ValueInequal
1242 <<< TestDiff/EqualMethod/StructA2/PointerInequal
1243   &teststructs.StructA2{
1244         StructA: &{X: "NotEqual"},
1245 -       X:       "NotEqual",
1246 +       X:       "not_equal",
1247   }
1248 >>> TestDiff/EqualMethod/StructA2/PointerInequal
1249 <<< TestDiff/EqualMethod/StructB2/ValueInequal
1250   teststructs.StructB2{
1251         StructB: &{X: "NotEqual"},
1252 -       X:       "NotEqual",
1253 +       X:       "not_equal",
1254   }
1255 >>> TestDiff/EqualMethod/StructB2/ValueInequal
1256 <<< TestDiff/EqualMethod/StructB2/PointerInequal
1257   &teststructs.StructB2{
1258         StructB: &{X: "NotEqual"},
1259 -       X:       "NotEqual",
1260 +       X:       "not_equal",
1261   }
1262 >>> TestDiff/EqualMethod/StructB2/PointerInequal
1263 <<< TestDiff/EqualMethod/StructNo/Inequal
1264   teststructs.StructNo{
1265 -       X: "NotEqual",
1266 +       X: "not_equal",
1267   }
1268 >>> TestDiff/EqualMethod/StructNo/Inequal
1269 <<< TestDiff/Cycle/PointersInequal
1270   &&⟪ref#0⟫cmp_test.P(
1271 -       &⟪ref#0⟫(...),
1272 +       &&⟪ref#0⟫(...),
1273   )
1274 >>> TestDiff/Cycle/PointersInequal
1275 <<< TestDiff/Cycle/SlicesInequal
1276   cmp_test.S{
1277 -       ⟪ref#0⟫{⟪ref#0⟫(...)},
1278 +       ⟪ref#1⟫{{⟪ref#1⟫(...)}},
1279   }
1280 >>> TestDiff/Cycle/SlicesInequal
1281 <<< TestDiff/Cycle/MapsInequal
1282   cmp_test.M⟪ref#0⟫{
1283 -       0: ⟪ref#0⟫(...),
1284 +       0: {0: ⟪ref#0⟫(...)},
1285   }
1286 >>> TestDiff/Cycle/MapsInequal
1287 <<< TestDiff/Cycle/GraphInequalZeroed
1288   map[string]*cmp_test.CycleAlpha{
1289         "Bar": &⟪ref#0⟫{
1290                 Name: "Bar",
1291                 Bravos: map[string]*cmp_test.CycleBravo{
1292                         "BarBuzzBravo": &⟪ref#1⟫{
1293 -                               ID:   102,
1294 +                               ID:   0,
1295                                 Name: "BarBuzzBravo",
1296                                 Mods: 2,
1297                                 Alphas: map[string]*cmp_test.CycleAlpha{
1298                                         "Bar": &⟪ref#0⟫(...),
1299                                         "Buzz": &⟪ref#2⟫{
1300                                                 Name: "Buzz",
1301                                                 Bravos: map[string]*cmp_test.CycleBravo{
1302                                                         "BarBuzzBravo": &⟪ref#1⟫(...),
1303                                                         "BuzzBarBravo": &⟪ref#3⟫{
1304 -                                                               ID:     103,
1305 +                                                               ID:     0,
1306                                                                 Name:   "BuzzBarBravo",
1307                                                                 Mods:   0,
1308                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1309                                                         },
1310                                                 },
1311                                         },
1312                                 },
1313                         },
1314                         "BuzzBarBravo": &⟪ref#3⟫{
1315 -                               ID:   103,
1316 +                               ID:   0,
1317                                 Name: "BuzzBarBravo",
1318                                 Mods: 0,
1319                                 Alphas: map[string]*cmp_test.CycleAlpha{
1320                                         "Bar": &⟪ref#0⟫(...),
1321                                         "Buzz": &⟪ref#2⟫{
1322                                                 Name: "Buzz",
1323                                                 Bravos: map[string]*cmp_test.CycleBravo{
1324                                                         "BarBuzzBravo": &⟪ref#1⟫{
1325 -                                                               ID:     102,
1326 +                                                               ID:     0,
1327                                                                 Name:   "BarBuzzBravo",
1328                                                                 Mods:   2,
1329                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1330                                                         },
1331                                                         "BuzzBarBravo": &⟪ref#3⟫(...),
1332                                                 },
1333                                         },
1334                                 },
1335                         },
1336                 },
1337         },
1338         "Buzz": &⟪ref#2⟫{
1339                 Name: "Buzz",
1340                 Bravos: map[string]*cmp_test.CycleBravo{
1341                         "BarBuzzBravo": &⟪ref#1⟫{
1342 -                               ID:   102,
1343 +                               ID:   0,
1344                                 Name: "BarBuzzBravo",
1345                                 Mods: 2,
1346                                 Alphas: map[string]*cmp_test.CycleAlpha{
1347                                         "Bar": &⟪ref#0⟫{
1348                                                 Name: "Bar",
1349                                                 Bravos: map[string]*cmp_test.CycleBravo{
1350                                                         "BarBuzzBravo": &⟪ref#1⟫(...),
1351                                                         "BuzzBarBravo": &⟪ref#3⟫{
1352 -                                                               ID:     103,
1353 +                                                               ID:     0,
1354                                                                 Name:   "BuzzBarBravo",
1355                                                                 Mods:   0,
1356                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1357                                                         },
1358                                                 },
1359                                         },
1360                                         "Buzz": &⟪ref#2⟫(...),
1361                                 },
1362                         },
1363                         "BuzzBarBravo": &⟪ref#3⟫{
1364 -                               ID:   103,
1365 +                               ID:   0,
1366                                 Name: "BuzzBarBravo",
1367                                 Mods: 0,
1368                                 Alphas: map[string]*cmp_test.CycleAlpha{
1369                                         "Bar": &⟪ref#0⟫{
1370                                                 Name: "Bar",
1371                                                 Bravos: map[string]*cmp_test.CycleBravo{
1372                                                         "BarBuzzBravo": &⟪ref#1⟫{
1373 -                                                               ID:     102,
1374 +                                                               ID:     0,
1375                                                                 Name:   "BarBuzzBravo",
1376                                                                 Mods:   2,
1377                                                                 Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1378                                                         },
1379                                                         "BuzzBarBravo": &⟪ref#3⟫(...),
1380                                                 },
1381                                         },
1382                                         "Buzz": &⟪ref#2⟫(...),
1383                                 },
1384                         },
1385                 },
1386         },
1387         "Foo": &⟪ref#4⟫{
1388                 Name: "Foo",
1389                 Bravos: map[string]*cmp_test.CycleBravo{
1390                         "FooBravo": &{
1391 -                               ID:     101,
1392 +                               ID:     0,
1393                                 Name:   "FooBravo",
1394                                 Mods:   100,
1395                                 Alphas: {"Foo": &⟪ref#4⟫(...)},
1396                         },
1397                 },
1398         },
1399   }
1400 >>> TestDiff/Cycle/GraphInequalZeroed
1401 <<< TestDiff/Cycle/GraphInequalStruct
1402   map[string]*cmp_test.CycleAlpha{
1403         "Bar": &⟪ref#0⟫{
1404                 Name: "Bar",
1405                 Bravos: map[string]*cmp_test.CycleBravo{
1406                         "BarBuzzBravo": &⟪ref#1⟫{
1407                                 ID:   102,
1408                                 Name: "BarBuzzBravo",
1409                                 Mods: 2,
1410                                 Alphas: map[string]*cmp_test.CycleAlpha{
1411                                         "Bar": &⟪ref#0⟫(...),
1412                                         "Buzz": &⟪ref#2⟫{
1413                                                 Name: "Buzz",
1414                                                 Bravos: map[string]*cmp_test.CycleBravo{
1415                                                         "BarBuzzBravo": &⟪ref#1⟫(...),
1416                                                         "BuzzBarBravo": &⟪ref#3⟫{
1417                                                                 ID:     103,
1418                                                                 Name:   "BuzzBarBravo",
1419                                                                 Mods:   0,
1420 -                                                               Alphas: nil,
1421 +                                                               Alphas: map[string]*cmp_test.CycleAlpha{"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)},
1422                                                         },
1423                                                 },
1424                                         },
1425                                 },
1426                         },
1427                         "BuzzBarBravo": &⟪ref#3⟫{
1428                                 ID:   103,
1429                                 Name: "BuzzBarBravo",
1430                                 Mods: 0,
1431                                 Alphas: map[string]*cmp_test.CycleAlpha{
1432                                         "Bar": &⟪ref#0⟫(...),
1433                                         "Buzz": &⟪ref#2⟫{
1434                                                 Name: "Buzz",
1435                                                 Bravos: map[string]*cmp_test.CycleBravo{
1436                                                         "BarBuzzBravo": &⟪ref#1⟫{ID: 102, Name: "BarBuzzBravo", Mods: 2, Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}},
1437 -                                                       "BuzzBarBravo": &{ID: 103, Name: "BuzzBarBravo"},
1438 +                                                       "BuzzBarBravo": &⟪ref#3⟫(...),
1439                                                 },
1440                                         },
1441                                 },
1442                         },
1443                 },
1444         },
1445         "Buzz": &⟪ref#2⟫{
1446                 Name: "Buzz",
1447                 Bravos: map[string]*cmp_test.CycleBravo{
1448                         "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⟫(...)}},
1449                         "BuzzBarBravo": &⟪ref#3⟫{
1450                                 ID:     103,
1451                                 Name:   "BuzzBarBravo",
1452                                 Mods:   0,
1453 -                               Alphas: nil,
1454 +                               Alphas: map[string]*cmp_test.CycleAlpha{
1455 +                                       "Bar": &⟪ref#0⟫{
1456 +                                               Name:   "Bar",
1457 +                                               Bravos: map[string]*cmp_test.CycleBravo{"BarBuzzBravo": &⟪ref#1⟫{...}, "BuzzBarBravo": &⟪ref#3⟫(...)},
1458 +                                       },
1459 +                                       "Buzz": &⟪ref#2⟫(...),
1460 +                               },
1461                         },
1462                 },
1463         },
1464         "Foo": &⟪ref#4⟫{Name: "Foo", Bravos: {"FooBravo": &{ID: 101, Name: "FooBravo", Mods: 100, Alphas: {"Foo": &⟪ref#4⟫(...)}}}},
1465   }
1466 >>> TestDiff/Cycle/GraphInequalStruct
1467 <<< TestDiff/Project1/ProtoInequal
1468   teststructs.Eagle{
1469         ... // 4 identical fields
1470         Dreamers: nil,
1471         Prong:    0,
1472         Slaps: []teststructs.Slap{
1473                 ... // 2 identical elements
1474                 {},
1475                 {},
1476                 {
1477                         Name:     "",
1478                         Desc:     "",
1479                         DescLong: "",
1480 -                       Args:     s"metadata",
1481 +                       Args:     s"metadata2",
1482                         Tense:    0,
1483                         Interval: 0,
1484                         ... // 3 identical fields
1485                 },
1486         },
1487         StateGoverner: "",
1488         PrankRating:   "",
1489         ... // 2 identical fields
1490   }
1491 >>> TestDiff/Project1/ProtoInequal
1492 <<< TestDiff/Project1/Inequal
1493   teststructs.Eagle{
1494         ... // 2 identical fields
1495         Desc:     "some description",
1496         DescLong: "",
1497         Dreamers: []teststructs.Dreamer{
1498                 {},
1499                 {
1500                         ... // 4 identical fields
1501                         ContSlaps:         nil,
1502                         ContSlapsInterval: 0,
1503                         Animal: []interface{}{
1504                                 teststructs.Goat{
1505                                         Target:     "corporation",
1506                                         Slaps:      nil,
1507                                         FunnyPrank: "",
1508                                         Immutable: &teststructs.GoatImmutable{
1509 -                                               ID:      "southbay2",
1510 +                                               ID:      "southbay",
1511 -                                               State:   &6,
1512 +                                               State:   &5,
1513                                                 Started: s"2009-11-10 23:00:00 +0000 UTC",
1514                                                 Stopped: s"0001-01-01 00:00:00 +0000 UTC",
1515                                                 ... // 1 ignored and 1 identical fields
1516                                         },
1517                                 },
1518                                 teststructs.Donkey{},
1519                         },
1520                         Ornamental: false,
1521                         Amoeba:     53,
1522                         ... // 5 identical fields
1523                 },
1524         },
1525         Prong: 0,
1526         Slaps: []teststructs.Slap{
1527                 {
1528                         ... // 6 identical fields
1529                         Homeland:   0,
1530                         FunnyPrank: "",
1531                         Immutable: &teststructs.SlapImmutable{
1532                                 ID:          "immutableSlap",
1533                                 Out:         nil,
1534 -                               MildSlap:    false,
1535 +                               MildSlap:    true,
1536                                 PrettyPrint: "",
1537                                 State:       nil,
1538                                 Started:     s"2009-11-10 23:00:00 +0000 UTC",
1539                                 Stopped:     s"0001-01-01 00:00:00 +0000 UTC",
1540                                 LastUpdate:  s"0001-01-01 00:00:00 +0000 UTC",
1541                                 LoveRadius: &teststructs.LoveRadius{
1542                                         Summer: &teststructs.SummerLove{
1543                                                 Summary: &teststructs.SummerLoveSummary{
1544                                                         Devices: []string{
1545                                                                 "foo",
1546 -                                                               "bar",
1547 -                                                               "baz",
1548                                                         },
1549                                                         ChangeType: {1, 2, 3},
1550                                                         ... // 1 ignored field
1551                                                 },
1552                                                 ... // 1 ignored field
1553                                         },
1554                                         ... // 1 ignored field
1555                                 },
1556                                 ... // 1 ignored field
1557                         },
1558                 },
1559         },
1560         StateGoverner: "",
1561         PrankRating:   "",
1562         ... // 2 identical fields
1563   }
1564 >>> TestDiff/Project1/Inequal
1565 <<< TestDiff/Project2/InequalOrder
1566   teststructs.GermBatch{
1567         DirtyGerms: map[int32][]*testprotos.Germ{
1568                 17: {s"germ1"},
1569                 18: {
1570 -                       s"germ2",
1571                         s"germ3",
1572                         s"germ4",
1573 +                       s"germ2",
1574                 },
1575         },
1576         CleanGerms: nil,
1577         GermMap:    {13: s"germ13", 21: s"germ21"},
1578         ... // 7 identical fields
1579   }
1580 >>> TestDiff/Project2/InequalOrder
1581 <<< TestDiff/Project2/Inequal
1582   teststructs.GermBatch{
1583         DirtyGerms: map[int32][]*testprotos.Germ{
1584 +               17: {s"germ1"},
1585                 18: Inverse(Sort, []*testprotos.Germ{
1586                         s"germ2",
1587                         s"germ3",
1588 -                       s"germ4",
1589                 }),
1590         },
1591         CleanGerms: nil,
1592         GermMap:    {13: s"germ13", 21: s"germ21"},
1593         DishMap: map[int32]*teststructs.Dish{
1594                 0: &{err: e"EOF"},
1595 -               1: nil,
1596 +               1: &{err: e"unexpected EOF"},
1597                 2: &{pb: s"dish"},
1598         },
1599         HasPreviousResult: true,
1600         DirtyID:           10,
1601         CleanID:           0,
1602 -       GermStrain:        421,
1603 +       GermStrain:        22,
1604         TotalDirtyGerms:   0,
1605         InfectedAt:        s"2009-11-10 23:00:00 +0000 UTC",
1606   }
1607 >>> TestDiff/Project2/Inequal
1608 <<< TestDiff/Project3/Inequal
1609   teststructs.Dirt{
1610 -       table:   &teststructs.MockTable{state: []string{"a", "c"}},
1611 +       table:   &teststructs.MockTable{state: []string{"a", "b", "c"}},
1612         ts:      12345,
1613 -       Discord: 554,
1614 +       Discord: 500,
1615 -       Proto:   testprotos.Dirt(Inverse(λ, s"blah")),
1616 +       Proto:   testprotos.Dirt(Inverse(λ, s"proto")),
1617         wizard: map[string]*testprotos.Wizard{
1618 -               "albus": s"dumbledore",
1619 -               "harry": s"potter",
1620 +               "harry": s"otter",
1621         },
1622         sadistic: nil,
1623         lastTime: 54321,
1624         ... // 1 ignored field
1625   }
1626 >>> TestDiff/Project3/Inequal
1627 <<< TestDiff/Project4/Inequal
1628   teststructs.Cartel{
1629         Headquarter: teststructs.Headquarter{
1630                 id:       5,
1631                 location: "moon",
1632                 subDivisions: []string{
1633 -                       "alpha",
1634                         "bravo",
1635                         "charlie",
1636                 },
1637                 incorporatedDate: s"0001-01-01 00:00:00 +0000 UTC",
1638                 metaData:         s"metadata",
1639                 privateMessage:   nil,
1640                 publicMessage: []uint8{
1641                         0x01,
1642                         0x02,
1643 -                       0x03,
1644 +                       0x04,
1645 -                       0x04,
1646 +                       0x03,
1647                         0x05,
1648                 },
1649                 horseBack: "abcdef",
1650                 rattle:    "",
1651                 ... // 5 identical fields
1652         },
1653         source:        "mars",
1654         creationDate:  s"0001-01-01 00:00:00 +0000 UTC",
1655         boss:          "al capone",
1656         lastCrimeDate: s"0001-01-01 00:00:00 +0000 UTC",
1657         poisons: []*teststructs.Poison{
1658                 &{
1659 -                       poisonType:   1,
1660 +                       poisonType:   5,
1661                         expiration:   s"2009-11-10 23:00:00 +0000 UTC",
1662                         manufacturer: "acme",
1663                         potency:      0,
1664                 },
1665 -               &{poisonType: 2, manufacturer: "acme2"},
1666         },
1667   }
1668 >>> TestDiff/Project4/Inequal