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