<<< TestDiff/Comparer/StructInequal struct{ A int; B int; C int }{ A: 1, B: 2, - C: 3, + C: 4, } >>> TestDiff/Comparer/StructInequal <<< TestDiff/Comparer/PointerStructInequal &struct{ A *int }{ - A: &4, + A: &5, } >>> TestDiff/Comparer/PointerStructInequal <<< TestDiff/Comparer/StructNestedPointerInequal &struct{ R *bytes.Buffer }{ - R: s"", + R: nil, } >>> TestDiff/Comparer/StructNestedPointerInequal <<< TestDiff/Comparer/RegexpInequal []*regexp.Regexp{ nil, - s"a*b*c*", + s"a*b*d*", } >>> TestDiff/Comparer/RegexpInequal <<< TestDiff/Comparer/TriplePointerInequal &&&int( - 0, + 1, ) >>> TestDiff/Comparer/TriplePointerInequal <<< TestDiff/Comparer/StringerInequal struct{ fmt.Stringer }( - s"hello", + s"hello2", ) >>> TestDiff/Comparer/StringerInequal <<< TestDiff/Comparer/DifferingHash [16]uint8{ - 0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8, 0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61, + 0x92, 0xeb, 0x5f, 0xfe, 0xe6, 0xae, 0x2f, 0xec, 0x3a, 0xd7, 0x1c, 0x77, 0x75, 0x31, 0x57, 0x8f, } >>> TestDiff/Comparer/DifferingHash <<< TestDiff/Comparer/NilStringer interface{}( - &fmt.Stringer(nil), ) >>> TestDiff/Comparer/NilStringer <<< TestDiff/Comparer/TarHeaders []cmp_test.tarHeader{ { ... // 4 identical fields Size: 1, ModTime: s"2009-11-10 23:00:00 +0000 UTC", - Typeflag: 48, + Typeflag: 0, Linkname: "", Uname: "user", ... // 6 identical fields }, { ... // 4 identical fields Size: 2, ModTime: s"2009-11-11 00:00:00 +0000 UTC", - Typeflag: 48, + Typeflag: 0, Linkname: "", Uname: "user", ... // 6 identical fields }, { ... // 4 identical fields Size: 4, ModTime: s"2009-11-11 01:00:00 +0000 UTC", - Typeflag: 48, + Typeflag: 0, Linkname: "", Uname: "user", ... // 6 identical fields }, { ... // 4 identical fields Size: 8, ModTime: s"2009-11-11 02:00:00 +0000 UTC", - Typeflag: 48, + Typeflag: 0, Linkname: "", Uname: "user", ... // 6 identical fields }, { ... // 4 identical fields Size: 16, ModTime: s"2009-11-11 03:00:00 +0000 UTC", - Typeflag: 48, + Typeflag: 0, Linkname: "", Uname: "user", ... // 6 identical fields }, } >>> TestDiff/Comparer/TarHeaders <<< TestDiff/Comparer/IrreflexiveComparison []int{ - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), - Inverse(λ, float64(NaN)), + Inverse(λ, float64(NaN)), } >>> TestDiff/Comparer/IrreflexiveComparison <<< TestDiff/Comparer/StringerMapKey map[*testprotos.Stringer]*testprotos.Stringer( - {s"hello": s"world"}, + nil, ) >>> TestDiff/Comparer/StringerMapKey <<< TestDiff/Comparer/StringerBacktick interface{}( - []*testprotos.Stringer{s`multi\nline\nline\nline`}, ) >>> TestDiff/Comparer/StringerBacktick <<< TestDiff/Comparer/DynamicMap []interface{}{ map[string]interface{}{ "avg": float64(0.278), - "hr": int(65), + "hr": float64(65), "name": string("Mark McGwire"), }, map[string]interface{}{ "avg": float64(0.288), - "hr": int(63), + "hr": float64(63), "name": string("Sammy Sosa"), }, } >>> TestDiff/Comparer/DynamicMap <<< TestDiff/Comparer/MapKeyPointer map[*int]string{ - &⟪0xdeadf00f⟫0: "hello", + &⟪0xdeadf00f⟫0: "world", } >>> TestDiff/Comparer/MapKeyPointer <<< TestDiff/Comparer/IgnoreSliceElements [2][]int{ {..., 1, 2, 3, ...}, { ... // 6 ignored and 1 identical elements - 20, + 2, ... // 3 ignored elements }, } >>> TestDiff/Comparer/IgnoreSliceElements <<< TestDiff/Comparer/IgnoreMapEntries [2]map[string]int{ {"KEEP3": 3, "keep1": 1, "keep2": 2, ...}, { ... // 2 ignored entries "keep1": 1, + "keep2": 2, }, } >>> TestDiff/Comparer/IgnoreMapEntries <<< TestDiff/Transformer/Uints uint8(Inverse(λ, uint16(Inverse(λ, uint32(Inverse(λ, uint64( - 0, + 1, ))))))) >>> TestDiff/Transformer/Uints <<< TestDiff/Transformer/Filtered []int{ Inverse(λ, int64(0)), - Inverse(λ, int64(-5)), + Inverse(λ, int64(3)), Inverse(λ, int64(0)), - Inverse(λ, int64(-1)), + Inverse(λ, int64(-5)), } >>> TestDiff/Transformer/Filtered <<< TestDiff/Transformer/DisjointOutput int(Inverse(λ, interface{}( - string("zero"), + float64(1), ))) >>> TestDiff/Transformer/DisjointOutput <<< TestDiff/Transformer/JSON string(Inverse(ParseJSON, map[string]interface{}{ "address": map[string]interface{}{ - "city": string("Los Angeles"), + "city": string("New York"), "postalCode": string("10021-3100"), - "state": string("CA"), + "state": string("NY"), "streetAddress": string("21 2nd Street"), }, "age": float64(25), "children": []interface{}{}, "firstName": string("John"), "isAlive": bool(true), "lastName": string("Smith"), "phoneNumbers": []interface{}{ map[string]interface{}{ - "number": string("212 555-4321"), + "number": string("212 555-1234"), "type": string("home"), }, map[string]interface{}{"number": string("646 555-4567"), "type": string("office")}, map[string]interface{}{"number": string("123 456-7890"), "type": string("mobile")}, }, + "spouse": nil, })) >>> TestDiff/Transformer/JSON <<< TestDiff/Transformer/AcyclicString cmp_test.StringBytes{ String: Inverse(SplitString, []string{ "some", "multi", - "Line", + "line", "string", }), Bytes: []uint8(Inverse(SplitBytes, [][]uint8{ {0x73, 0x6f, 0x6d, 0x65}, {0x6d, 0x75, 0x6c, 0x74, ...}, {0x6c, 0x69, 0x6e, 0x65}, { - 0x62, + 0x42, 0x79, 0x74, ... // 2 identical elements }, })), } >>> TestDiff/Transformer/AcyclicString <<< TestDiff/Reporter/PanicStringer struct{ X fmt.Stringer }{ - X: struct{ fmt.Stringer }{}, + X: s"", } >>> TestDiff/Reporter/PanicStringer <<< TestDiff/Reporter/PanicError struct{ X error }{ - X: struct{ error }{}, + X: e"", } >>> TestDiff/Reporter/PanicError <<< TestDiff/Reporter/AmbiguousType interface{}( - "github.com/google/go-cmp/cmp/internal/teststructs/foo1".Bar{}, + "github.com/google/go-cmp/cmp/internal/teststructs/foo2".Bar{}, ) >>> TestDiff/Reporter/AmbiguousType <<< TestDiff/Reporter/AmbiguousPointer (*int)( - &⟪0xdeadf00f⟫0, + &⟪0xdeadf00f⟫0, ) >>> TestDiff/Reporter/AmbiguousPointer <<< TestDiff/Reporter/AmbiguousPointerStruct struct{ I *int }{ - I: &⟪0xdeadf00f⟫0, + I: &⟪0xdeadf00f⟫0, } >>> TestDiff/Reporter/AmbiguousPointerStruct <<< TestDiff/Reporter/AmbiguousPointerSlice []*int{ - &⟪0xdeadf00f⟫0, + &⟪0xdeadf00f⟫0, } >>> TestDiff/Reporter/AmbiguousPointerSlice <<< TestDiff/Reporter/AmbiguousPointerMap map[string]*int{ - "zero": &⟪0xdeadf00f⟫0, + "zero": &⟪0xdeadf00f⟫0, } >>> TestDiff/Reporter/AmbiguousPointerMap <<< TestDiff/Reporter/AmbiguousStringer interface{}( - cmp_test.Stringer("hello"), + &cmp_test.Stringer("hello"), ) >>> TestDiff/Reporter/AmbiguousStringer <<< TestDiff/Reporter/AmbiguousStringerStruct struct{ S fmt.Stringer }{ - S: cmp_test.Stringer("hello"), + S: &cmp_test.Stringer("hello"), } >>> TestDiff/Reporter/AmbiguousStringerStruct <<< TestDiff/Reporter/AmbiguousStringerSlice []fmt.Stringer{ - cmp_test.Stringer("hello"), + &cmp_test.Stringer("hello"), } >>> TestDiff/Reporter/AmbiguousStringerSlice <<< TestDiff/Reporter/AmbiguousStringerMap map[string]fmt.Stringer{ - "zero": cmp_test.Stringer("hello"), + "zero": &cmp_test.Stringer("hello"), } >>> TestDiff/Reporter/AmbiguousStringerMap <<< TestDiff/Reporter/AmbiguousSliceHeader []int( - ⟪ptr:0xdeadf00f, len:0, cap:5⟫{}, + ⟪ptr:0xdeadf00f, len:0, cap:1000⟫{}, ) >>> TestDiff/Reporter/AmbiguousSliceHeader <<< TestDiff/Reporter/AmbiguousStringerMapKey map[interface{}]string{ - nil: "nil", + &⟪0xdeadf00f⟫"github.com/google/go-cmp/cmp_test".Stringer("hello"): "goodbye", - "github.com/google/go-cmp/cmp_test".Stringer("hello"): "goodbye", - "github.com/google/go-cmp/cmp/internal/teststructs/foo1".Bar{S: "fizz"}: "buzz", + "github.com/google/go-cmp/cmp/internal/teststructs/foo2".Bar{S: "fizz"}: "buzz", } >>> TestDiff/Reporter/AmbiguousStringerMapKey <<< TestDiff/Reporter/NonAmbiguousStringerMapKey map[interface{}]string{ + s"fizz": "buzz", - s"hello": "goodbye", } >>> TestDiff/Reporter/NonAmbiguousStringerMapKey <<< TestDiff/Reporter/InvalidUTF8 interface{}( - cmp_test.MyString("\xed\xa0\x80"), ) >>> TestDiff/Reporter/InvalidUTF8 <<< TestDiff/Reporter/UnbatchedSlice cmp_test.MyComposite{ ... // 3 identical fields BytesB: nil, BytesC: nil, IntsA: []int8{ + 10, 11, - 12, + 21, 13, 14, ... // 15 identical elements }, IntsB: nil, IntsC: nil, ... // 6 identical fields } >>> TestDiff/Reporter/UnbatchedSlice <<< TestDiff/Reporter/BatchedSlice cmp_test.MyComposite{ ... // 3 identical fields BytesB: nil, BytesC: nil, IntsA: []int8{ - 10, 11, 12, 13, 14, 15, 16, + 12, 29, 13, 27, 22, 23, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, + 10, 26, 16, 25, 28, 11, 15, 24, 14, }, IntsB: nil, IntsC: nil, ... // 6 identical fields } >>> TestDiff/Reporter/BatchedSlice <<< TestDiff/Reporter/BatchedWithComparer cmp_test.MyComposite{ StringA: "", StringB: "", BytesA: []uint8{ - 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, // -|.......| + 0x0c, 0x1d, 0x0d, 0x1b, 0x16, 0x17, // +|......| 0x11, 0x12, 0x13, 0x14, 0x15, // |.....| - 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, // -|........| + 0x0a, 0x1a, 0x10, 0x19, 0x1c, 0x0b, 0x0f, 0x18, 0x0e, // +|.........| }, BytesB: nil, BytesC: nil, ... // 9 identical fields } >>> TestDiff/Reporter/BatchedWithComparer <<< TestDiff/Reporter/BatchedLong interface{}( - cmp_test.MyComposite{IntsA: []int8{0, 1, 2, 3, 4, 5, 6, 7, ...}}, ) >>> TestDiff/Reporter/BatchedLong <<< TestDiff/Reporter/BatchedNamedAndUnnamed cmp_test.MyComposite{ StringA: "", StringB: "", BytesA: []uint8{ - 0x01, 0x02, 0x03, // -|...| + 0x03, 0x02, 0x01, // +|...| }, BytesB: []cmp_test.MyByte{ - 0x04, 0x05, 0x06, + 0x06, 0x05, 0x04, }, BytesC: cmp_test.MyBytes{ - 0x07, 0x08, 0x09, // -|...| + 0x09, 0x08, 0x07, // +|...| }, IntsA: []int8{ - -1, -2, -3, + -3, -2, -1, }, IntsB: []cmp_test.MyInt{ - -4, -5, -6, + -6, -5, -4, }, IntsC: cmp_test.MyInts{ - -7, -8, -9, + -9, -8, -7, }, UintsA: []uint16{ - 1000, 2000, 3000, + 3000, 2000, 1000, }, UintsB: []cmp_test.MyUint{ - 4000, 5000, 6000, + 6000, 5000, 4000, }, UintsC: cmp_test.MyUints{ - 7000, 8000, 9000, + 9000, 8000, 7000, }, FloatsA: []float32{ - 1.5, 2.5, 3.5, + 3.5, 2.5, 1.5, }, FloatsB: []cmp_test.MyFloat{ - 4.5, 5.5, 6.5, + 6.5, 5.5, 4.5, }, FloatsC: cmp_test.MyFloats{ - 7.5, 8.5, 9.5, + 9.5, 8.5, 7.5, }, } >>> TestDiff/Reporter/BatchedNamedAndUnnamed <<< TestDiff/Reporter/BinaryHexdump cmp_test.MyComposite{ StringA: "", StringB: "", BytesA: []uint8{ 0xf3, 0x0f, 0x8a, 0xa4, 0xd3, 0x12, 0x52, 0x09, 0x24, 0xbe, // |......R.$.| - 0x58, 0x95, 0x41, 0xfd, 0x24, 0x66, 0x58, 0x8b, 0x79, // -|X.A.$fX.y| 0x54, 0xac, 0x0d, 0xd8, 0x71, 0x77, 0x70, 0x20, 0x6a, 0x5c, 0x73, 0x7f, 0x8c, 0x17, 0x55, 0xc0, // |T...qwp j\s...U.| 0x34, 0xce, 0x6e, 0xf7, 0xaa, 0x47, 0xee, 0x32, 0x9d, 0xc5, 0xca, 0x1e, 0x58, 0xaf, 0x8f, 0x27, // |4.n..G.2....X..'| 0xf3, 0x02, 0x4a, 0x90, 0xed, 0x69, 0x2e, 0x70, 0x32, 0xb4, 0xab, 0x30, 0x20, 0xb6, 0xbd, 0x5c, // |..J..i.p2..0 ..\| 0x62, 0x34, 0x17, 0xb0, 0x00, 0xbb, 0x4f, 0x7e, 0x27, 0x47, 0x06, 0xf4, 0x2e, 0x66, 0xfd, 0x63, // |b4....O~'G...f.c| 0xd7, 0x04, 0xdd, 0xb7, 0x30, 0xb7, 0xd1, // |....0..| - 0x55, 0x7e, 0x7b, 0xf6, 0xb3, 0x7e, 0x1d, 0x57, 0x69, // -|U~{..~.Wi| + 0x75, 0x2d, 0x5b, 0x5d, 0x5d, 0xf6, 0xb3, 0x68, 0x61, 0x68, 0x61, 0x7e, 0x1d, 0x57, 0x49, // +|u-[]]..haha~.WI| 0x20, 0x9e, 0xbc, 0xdf, 0xe1, 0x4d, 0xa9, 0xef, 0xa2, 0xd2, 0xed, 0xb4, 0x47, 0x78, 0xc9, 0xc9, // | ....M......Gx..| 0x27, 0xa4, 0xc6, 0xce, 0xec, 0x44, 0x70, 0x5d, // |'....Dp]| }, BytesB: nil, BytesC: nil, ... // 9 identical fields } >>> TestDiff/Reporter/BinaryHexdump <<< TestDiff/Reporter/StringHexdump cmp_test.MyComposite{ StringA: "", StringB: cmp_test.MyString{ - 0x72, 0x65, 0x61, 0x64, 0x6d, 0x65, // -|readme| + 0x67, 0x6f, 0x70, 0x68, 0x65, 0x72, // +|gopher| 0x2e, 0x74, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |.txt............| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |................| ... // 64 identical bytes 0x30, 0x30, 0x36, 0x30, 0x30, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x30, // |00600.0000000.00| 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, // |00000.0000000004| - 0x36, // -|6| + 0x33, // +|3| 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x31, 0x31, // |.00000000000.011| - 0x31, 0x37, 0x33, // -|173| + 0x32, 0x31, 0x37, // +|217| 0x00, 0x20, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |. 0.............| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |................| ... // 326 identical bytes }, BytesA: nil, BytesB: nil, ... // 10 identical fields } >>> TestDiff/Reporter/StringHexdump <<< TestDiff/Reporter/BinaryString cmp_test.MyComposite{ StringA: "", StringB: "", BytesA: bytes.Join({ `{"firstName":"John","lastName":"Smith","isAlive":true,"age":27,"`, `address":{"streetAddress":"`, - "314 54th Avenue", + "21 2nd Street", `","city":"New York","state":"NY","postalCode":"10021-3100"},"pho`, `neNumbers":[{"type":"home","number":"212 555-1234"},{"type":"off`, ... // 101 identical bytes }, ""), BytesB: nil, BytesC: nil, ... // 9 identical fields } >>> TestDiff/Reporter/BinaryString <<< TestDiff/Reporter/TripleQuote cmp_test.MyComposite{ StringA: ( """ aaa bbb - ccc + CCC ddd eee ... // 10 identical lines ppp qqq - RRR - sss + rrr + SSS ttt uuu ... // 6 identical lines """ ), StringB: "", BytesA: nil, ... // 11 identical fields } >>> TestDiff/Reporter/TripleQuote <<< TestDiff/Reporter/TripleQuoteSlice []string{ ( """ ... // 23 identical lines xxx yyy - zzz """ ), "aaa\nbbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\nkkk\nlll\nmmm\nnnn\nooo\nppp\n"..., } >>> TestDiff/Reporter/TripleQuoteSlice <<< TestDiff/Reporter/TripleQuoteNamedTypes cmp_test.MyComposite{ StringA: "", StringB: ( """ aaa bbb - ccc + CCC ddd eee ... // 10 identical lines ppp qqq - RRR - sss + rrr + SSS ttt uuu ... // 5 identical lines """ ), BytesA: nil, BytesB: nil, BytesC: cmp_test.MyBytes( """ aaa bbb - ccc + CCC ddd eee ... // 10 identical lines ppp qqq - RRR - sss + rrr + SSS ttt uuu ... // 5 identical lines """ ), IntsA: nil, IntsB: nil, ... // 7 identical fields } >>> TestDiff/Reporter/TripleQuoteNamedTypes <<< TestDiff/Reporter/TripleQuoteSliceNamedTypes []cmp_test.MyString{ ( """ ... // 23 identical lines xxx yyy - zzz """ ), "aaa\nbbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\nkkk\nlll\nmmm\nnnn\nooo\nppp\n"..., } >>> TestDiff/Reporter/TripleQuoteSliceNamedTypes <<< TestDiff/Reporter/TripleQuoteEndlines ( """ aaa bbb - ccc + CCC ddd eee ... // 10 identical lines ppp qqq - RRR + rrr sss ttt ... // 4 identical lines yyy zzz - """ ) >>> TestDiff/Reporter/TripleQuoteEndlines <<< TestDiff/Reporter/AvoidTripleQuoteAmbiguousQuotes strings.Join({ "aaa", "bbb", - "ccc", + "CCC", "ddd", "eee", - "fff", + `"""`, "ggg", "hhh", ... // 7 identical lines "ppp", "qqq", - "RRR", + "rrr", "sss", "ttt", ... // 7 identical lines }, "\n") >>> TestDiff/Reporter/AvoidTripleQuoteAmbiguousQuotes <<< TestDiff/Reporter/AvoidTripleQuoteAmbiguousEllipsis strings.Join({ "aaa", "bbb", - "ccc", - "...", + "CCC", + "ddd", "eee", "fff", ... // 9 identical lines "ppp", "qqq", - "RRR", + "rrr", "sss", "ttt", ... // 7 identical lines }, "\n") >>> TestDiff/Reporter/AvoidTripleQuoteAmbiguousEllipsis <<< TestDiff/Reporter/AvoidTripleQuoteNonPrintable strings.Join({ "aaa", "bbb", - "ccc", + "CCC", "ddd", "eee", ... // 7 identical lines "mmm", "nnn", - "ooo", + "o\roo", "ppp", "qqq", - "RRR", + "rrr", "sss", "ttt", ... // 7 identical lines }, "\n") >>> TestDiff/Reporter/AvoidTripleQuoteNonPrintable <<< TestDiff/Reporter/AvoidTripleQuoteIdenticalWhitespace strings.Join({ "aaa", "bbb", - "ccc", - " ddd", + "ccc ", + "ddd", "eee", "fff", ... // 9 identical lines "ppp", "qqq", - "RRR", + "rrr", "sss", "ttt", ... // 7 identical lines }, "\n") >>> TestDiff/Reporter/AvoidTripleQuoteIdenticalWhitespace <<< TestDiff/Reporter/TripleQuoteStringer []fmt.Stringer{ s"package main\n\nimport (\n\t\"fmt\"\n)\n\nfunc main() {\n\tfmt.Println(\"Hel"..., - ( - s""" - package main - - import ( - "fmt" - "math/rand" - ) - - func main() { - fmt.Println("My favorite number is", rand.Intn(10)) - } - s""" - ), + ( + s""" + package main + + import ( + "fmt" + "math" + ) + + func main() { + fmt.Printf("Now you have %g problems.\n", math.Sqrt(7)) + } + s""" + ), } >>> TestDiff/Reporter/TripleQuoteStringer <<< TestDiff/Reporter/LimitMaximumBytesDiffs []uint8{ - 0xcd, 0x3d, 0x3d, 0x3d, 0x3d, 0x06, 0x1f, 0xc2, 0xcc, 0xc2, 0x2d, 0x53, // -|.====.....-S| + 0x5c, 0x3d, 0x3d, 0x3d, 0x3d, 0x7c, 0x96, 0xe7, 0x53, 0x42, 0xa0, 0xab, // +|\====|..SB..| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |=====| - 0x1d, 0xdf, 0x61, 0xae, 0x98, 0x9f, 0x48, // -|..a...H| + 0xf0, 0xbd, 0xa5, 0x71, 0xab, 0x17, 0x3b, // +|...q..;| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |======| - 0xc7, 0xb0, 0xb7, // -|...| + 0xab, 0x50, 0x00, // +|.P.| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |=======| - 0xef, 0x3d, 0x3d, 0x3d, 0x3d, 0x3a, 0x5c, 0x94, 0xe6, 0x4a, 0xc7, // -|.====:\..J.| + 0xeb, 0x3d, 0x3d, 0x3d, 0x3d, 0xa5, 0x14, 0xe6, 0x4f, 0x28, 0xe4, // +|.====...O(.| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |=====| - 0xb4, // -|.| + 0x28, // +|(| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |======| - 0x0a, 0x0a, 0xf7, 0x94, // -|....| + 0x2f, 0x63, 0x40, 0x3f, // +|/c@?| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |===========| - 0xf2, 0x9c, 0xc0, 0x66, // -|...f| + 0xd9, 0x78, 0xed, 0x13, // +|.x..| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |=====| - 0x34, 0xf6, 0xf1, 0xc3, 0x17, 0x82, // -|4.....| + 0x4a, 0xfc, 0x91, 0x38, 0x42, 0x8d, // +|J..8B.| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |======| - 0x6e, 0x16, 0x60, 0x91, 0x44, 0xc6, 0x06, // -|n.`.D..| + 0x61, 0x38, 0x41, 0xeb, 0x73, 0x04, 0xae, // +|a8A.s..| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |=======| - 0x1c, 0x45, 0x3d, 0x3d, 0x3d, 0x3d, 0x2e, // -|.E====.| + 0x07, 0x43, 0x3d, 0x3d, 0x3d, 0x3d, 0x1c, // +|.C====.| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |===========| - 0xc4, 0x18, // -|..| + 0x91, 0x22, // +|."| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |=======| - 0x8a, 0x8d, 0x0e, 0x3d, 0x3d, 0x3d, 0x3d, 0x87, 0xb1, 0xa5, 0x8e, 0xc3, 0x3d, 0x3d, 0x3d, 0x3d, // -|...====.....====| - 0x3d, 0x7a, 0x0f, 0x31, 0xae, 0x55, 0x3d, // -|=z.1.U=| + 0x75, 0xd8, 0xbe, 0x3d, 0x3d, 0x3d, 0x3d, 0x73, 0xec, 0x84, 0x35, 0x07, 0x3d, 0x3d, 0x3d, 0x3d, // +|u..====s..5.====| + 0x3d, 0x3b, 0xab, 0x53, 0x39, 0x74, // +|=;.S9t| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |=====| - 0x47, 0x2c, 0x3d, // -|G,=| + 0x3d, 0x1f, 0x1b, // +|=..| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |======| - 0x35, 0xe7, 0x35, 0xee, 0x82, 0xf4, 0xce, 0x3d, 0x3d, 0x3d, 0x3d, 0x11, 0x72, 0x3d, // -|5.5....====.r=| + 0x3d, 0x80, 0xab, 0x2f, 0xed, 0x2b, 0x3a, 0x3b, 0x3d, 0x3d, 0x3d, 0x3d, 0xea, 0x49, // +|=../.+:;====.I| 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, // |==========| - 0xaf, 0x5d, 0x3d, // -|.]=| + 0x3d, 0xab, 0x6c, // +|=.l| ... // 51 identical, 34 removed, and 35 inserted bytes } >>> TestDiff/Reporter/LimitMaximumBytesDiffs <<< TestDiff/Reporter/LimitMaximumStringDiffs ( """ - a + aa b - c + cc d - e + ee f - g + gg h - i + ii j - k + kk l - m + mm n - o + oo p - q + qq r - s + ss t - u + uu v - w + ww x - y + yy z - A + AA B - C + CC D - E + EE ... // 12 identical, 10 removed, and 10 inserted lines """ ) >>> TestDiff/Reporter/LimitMaximumStringDiffs <<< TestDiff/Reporter/LimitMaximumSliceDiffs []struct{ S string }{ - {S: "a"}, + {S: "aa"}, {S: "b"}, - {S: "c"}, + {S: "cc"}, {S: "d"}, - {S: "e"}, + {S: "ee"}, {S: "f"}, - {S: "g"}, + {S: "gg"}, {S: "h"}, - {S: "i"}, + {S: "ii"}, {S: "j"}, - {S: "k"}, + {S: "kk"}, {S: "l"}, - {S: "m"}, + {S: "mm"}, {S: "n"}, - {S: "o"}, + {S: "oo"}, {S: "p"}, - {S: "q"}, + {S: "qq"}, {S: "r"}, - {S: "s"}, + {S: "ss"}, {S: "t"}, - {S: "u"}, + {S: "uu"}, {S: "v"}, - {S: "w"}, + {S: "ww"}, {S: "x"}, - {S: "y"}, + {S: "yy"}, {S: "z"}, - {S: "A"}, + {S: "AA"}, {S: "B"}, - {S: "C"}, + {S: "CC"}, {S: "D"}, - {S: "E"}, + {S: "EE"}, ... // 12 identical and 10 modified elements } >>> TestDiff/Reporter/LimitMaximumSliceDiffs <<< TestDiff/Reporter/MultilineString cmp_test.MyComposite{ StringA: ( """ - Package cmp determines equality of values. + Package cmp determines equality of value. This package is intended to be a more powerful and safer alternative to ... // 6 identical lines For example, an equality function may report floats as equal so long as they are within some tolerance of each other. - - • Types that have an Equal method may use that method to determine equality. - This allows package authors to determine the equality operation for the types - that they define. • If no custom equality functions are used and no Equal method is defined, ... // 3 identical lines by using an Ignore option (see cmpopts.IgnoreUnexported) or explicitly compared using the AllowUnexported option. - """ ), StringB: "", BytesA: nil, ... // 11 identical fields } >>> TestDiff/Reporter/MultilineString <<< TestDiff/Reporter/Slices cmp_test.MyComposite{ StringA: "", StringB: "", - BytesA: []uint8{0x01, 0x02, 0x03}, + BytesA: nil, - BytesB: []cmp_test.MyByte{0x04, 0x05, 0x06}, + BytesB: nil, - BytesC: cmp_test.MyBytes{0x07, 0x08, 0x09}, + BytesC: nil, - IntsA: []int8{-1, -2, -3}, + IntsA: nil, - IntsB: []cmp_test.MyInt{-4, -5, -6}, + IntsB: nil, - IntsC: cmp_test.MyInts{-7, -8, -9}, + IntsC: nil, - UintsA: []uint16{1000, 2000, 3000}, + UintsA: nil, - UintsB: []cmp_test.MyUint{4000, 5000, 6000}, + UintsB: nil, - UintsC: cmp_test.MyUints{7000, 8000, 9000}, + UintsC: nil, - FloatsA: []float32{1.5, 2.5, 3.5}, + FloatsA: nil, - FloatsB: []cmp_test.MyFloat{4.5, 5.5, 6.5}, + FloatsB: nil, - FloatsC: cmp_test.MyFloats{7.5, 8.5, 9.5}, + FloatsC: nil, } >>> TestDiff/Reporter/Slices <<< TestDiff/Reporter/EmptySlices cmp_test.MyComposite{ StringA: "", StringB: "", - BytesA: []uint8{}, + BytesA: nil, - BytesB: []cmp_test.MyByte{}, + BytesB: nil, - BytesC: cmp_test.MyBytes{}, + BytesC: nil, - IntsA: []int8{}, + IntsA: nil, - IntsB: []cmp_test.MyInt{}, + IntsB: nil, - IntsC: cmp_test.MyInts{}, + IntsC: nil, - UintsA: []uint16{}, + UintsA: nil, - UintsB: []cmp_test.MyUint{}, + UintsB: nil, - UintsC: cmp_test.MyUints{}, + UintsC: nil, - FloatsA: []float32{}, + FloatsA: nil, - FloatsB: []cmp_test.MyFloat{}, + FloatsB: nil, - FloatsC: cmp_test.MyFloats{}, + FloatsC: nil, } >>> TestDiff/Reporter/EmptySlices <<< TestDiff/EmbeddedStruct/ParentStructA/Inequal teststructs.ParentStructA{ privateStruct: teststructs.privateStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, } >>> TestDiff/EmbeddedStruct/ParentStructA/Inequal <<< TestDiff/EmbeddedStruct/ParentStructB/Inequal teststructs.ParentStructB{ PublicStruct: teststructs.PublicStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, } >>> TestDiff/EmbeddedStruct/ParentStructB/Inequal <<< TestDiff/EmbeddedStruct/ParentStructC/Inequal teststructs.ParentStructC{ privateStruct: teststructs.privateStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, - Public: 3, + Public: 4, - private: 4, + private: 5, } >>> TestDiff/EmbeddedStruct/ParentStructC/Inequal <<< TestDiff/EmbeddedStruct/ParentStructD/Inequal teststructs.ParentStructD{ PublicStruct: teststructs.PublicStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, - Public: 3, + Public: 4, - private: 4, + private: 5, } >>> TestDiff/EmbeddedStruct/ParentStructD/Inequal <<< TestDiff/EmbeddedStruct/ParentStructE/Inequal teststructs.ParentStructE{ privateStruct: teststructs.privateStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, PublicStruct: teststructs.PublicStruct{ - Public: 3, + Public: 4, - private: 4, + private: 5, }, } >>> TestDiff/EmbeddedStruct/ParentStructE/Inequal <<< TestDiff/EmbeddedStruct/ParentStructF/Inequal teststructs.ParentStructF{ privateStruct: teststructs.privateStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, PublicStruct: teststructs.PublicStruct{ - Public: 3, + Public: 4, - private: 4, + private: 5, }, - Public: 5, + Public: 6, - private: 6, + private: 7, } >>> TestDiff/EmbeddedStruct/ParentStructF/Inequal <<< TestDiff/EmbeddedStruct/ParentStructG/Inequal &teststructs.ParentStructG{ privateStruct: &teststructs.privateStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, } >>> TestDiff/EmbeddedStruct/ParentStructG/Inequal <<< TestDiff/EmbeddedStruct/ParentStructH/Inequal &teststructs.ParentStructH{ PublicStruct: &teststructs.PublicStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, } >>> TestDiff/EmbeddedStruct/ParentStructH/Inequal <<< TestDiff/EmbeddedStruct/ParentStructI/Inequal &teststructs.ParentStructI{ privateStruct: &teststructs.privateStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, PublicStruct: &teststructs.PublicStruct{ - Public: 3, + Public: 4, - private: 4, + private: 5, }, } >>> TestDiff/EmbeddedStruct/ParentStructI/Inequal <<< TestDiff/EmbeddedStruct/ParentStructJ/Inequal &teststructs.ParentStructJ{ privateStruct: &teststructs.privateStruct{ - Public: 1, + Public: 2, - private: 2, + private: 3, }, PublicStruct: &teststructs.PublicStruct{ - Public: 3, + Public: 4, - private: 4, + private: 5, }, Public: teststructs.PublicStruct{ - Public: 7, + Public: 8, - private: 8, + private: 9, }, private: teststructs.privateStruct{ - Public: 5, + Public: 6, - private: 6, + private: 7, }, } >>> TestDiff/EmbeddedStruct/ParentStructJ/Inequal <<< TestDiff/EqualMethod/StructB/ValueInequal teststructs.StructB{ - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructB/ValueInequal <<< TestDiff/EqualMethod/StructD/ValueInequal teststructs.StructD{ - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructD/ValueInequal <<< TestDiff/EqualMethod/StructE/ValueInequal teststructs.StructE{ - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructE/ValueInequal <<< TestDiff/EqualMethod/StructF/ValueInequal teststructs.StructF{ - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructF/ValueInequal <<< TestDiff/EqualMethod/StructA1/ValueInequal teststructs.StructA1{ StructA: {X: "NotEqual"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructA1/ValueInequal <<< TestDiff/EqualMethod/StructA1/PointerInequal &teststructs.StructA1{ StructA: {X: "NotEqual"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructA1/PointerInequal <<< TestDiff/EqualMethod/StructB1/ValueInequal teststructs.StructB1{ StructB: Inverse(Addr, &teststructs.StructB{X: "NotEqual"}), - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructB1/ValueInequal <<< TestDiff/EqualMethod/StructB1/PointerInequal &teststructs.StructB1{ StructB: Inverse(Addr, &teststructs.StructB{X: "NotEqual"}), - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructB1/PointerInequal <<< TestDiff/EqualMethod/StructD1/ValueInequal teststructs.StructD1{ - StructD: teststructs.StructD{X: "NotEqual"}, + StructD: teststructs.StructD{X: "not_equal"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructD1/ValueInequal <<< TestDiff/EqualMethod/StructE1/ValueInequal teststructs.StructE1{ - StructE: teststructs.StructE{X: "NotEqual"}, + StructE: teststructs.StructE{X: "not_equal"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructE1/ValueInequal <<< TestDiff/EqualMethod/StructF1/ValueInequal teststructs.StructF1{ - StructF: teststructs.StructF{X: "NotEqual"}, + StructF: teststructs.StructF{X: "not_equal"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructF1/ValueInequal <<< TestDiff/EqualMethod/StructA2/ValueInequal teststructs.StructA2{ StructA: &{X: "NotEqual"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructA2/ValueInequal <<< TestDiff/EqualMethod/StructA2/PointerInequal &teststructs.StructA2{ StructA: &{X: "NotEqual"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructA2/PointerInequal <<< TestDiff/EqualMethod/StructB2/ValueInequal teststructs.StructB2{ StructB: &{X: "NotEqual"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructB2/ValueInequal <<< TestDiff/EqualMethod/StructB2/PointerInequal &teststructs.StructB2{ StructB: &{X: "NotEqual"}, - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructB2/PointerInequal <<< TestDiff/EqualMethod/StructNo/Inequal teststructs.StructNo{ - X: "NotEqual", + X: "not_equal", } >>> TestDiff/EqualMethod/StructNo/Inequal <<< TestDiff/Cycle/PointersInequal &&⟪ref#0⟫cmp_test.P( - &⟪ref#0⟫(...), + &&⟪ref#0⟫(...), ) >>> TestDiff/Cycle/PointersInequal <<< TestDiff/Cycle/SlicesInequal cmp_test.S{ - ⟪ref#0⟫{⟪ref#0⟫(...)}, + ⟪ref#1⟫{{⟪ref#1⟫(...)}}, } >>> TestDiff/Cycle/SlicesInequal <<< TestDiff/Cycle/MapsInequal cmp_test.M⟪ref#0⟫{ - 0: ⟪ref#0⟫(...), + 0: {0: ⟪ref#0⟫(...)}, } >>> TestDiff/Cycle/MapsInequal <<< TestDiff/Cycle/GraphInequalZeroed map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫{ Name: "Bar", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫{ - ID: 102, + ID: 0, Name: "BarBuzzBravo", Mods: 2, Alphas: map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫{ Name: "Buzz", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫(...), "BuzzBarBravo": &⟪ref#3⟫{ - ID: 103, + ID: 0, Name: "BuzzBarBravo", Mods: 0, Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}, }, }, }, }, }, "BuzzBarBravo": &⟪ref#3⟫{ - ID: 103, + ID: 0, Name: "BuzzBarBravo", Mods: 0, Alphas: map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫{ Name: "Buzz", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫{ - ID: 102, + ID: 0, Name: "BarBuzzBravo", Mods: 2, Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}, }, "BuzzBarBravo": &⟪ref#3⟫(...), }, }, }, }, }, }, "Buzz": &⟪ref#2⟫{ Name: "Buzz", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫{ - ID: 102, + ID: 0, Name: "BarBuzzBravo", Mods: 2, Alphas: map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫{ Name: "Bar", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫(...), "BuzzBarBravo": &⟪ref#3⟫{ - ID: 103, + ID: 0, Name: "BuzzBarBravo", Mods: 0, Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}, }, }, }, "Buzz": &⟪ref#2⟫(...), }, }, "BuzzBarBravo": &⟪ref#3⟫{ - ID: 103, + ID: 0, Name: "BuzzBarBravo", Mods: 0, Alphas: map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫{ Name: "Bar", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫{ - ID: 102, + ID: 0, Name: "BarBuzzBravo", Mods: 2, Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}, }, "BuzzBarBravo": &⟪ref#3⟫(...), }, }, "Buzz": &⟪ref#2⟫(...), }, }, }, }, "Foo": &⟪ref#4⟫{ Name: "Foo", Bravos: map[string]*cmp_test.CycleBravo{ "FooBravo": &{ - ID: 101, + ID: 0, Name: "FooBravo", Mods: 100, Alphas: {"Foo": &⟪ref#4⟫(...)}, }, }, }, } >>> TestDiff/Cycle/GraphInequalZeroed <<< TestDiff/Cycle/GraphInequalStruct map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫{ Name: "Bar", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫{ ID: 102, Name: "BarBuzzBravo", Mods: 2, Alphas: map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫{ Name: "Buzz", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫(...), "BuzzBarBravo": &⟪ref#3⟫{ ID: 103, Name: "BuzzBarBravo", Mods: 0, - Alphas: nil, + Alphas: map[string]*cmp_test.CycleAlpha{"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}, }, }, }, }, }, "BuzzBarBravo": &⟪ref#3⟫{ ID: 103, Name: "BuzzBarBravo", Mods: 0, Alphas: map[string]*cmp_test.CycleAlpha{ "Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫{ Name: "Buzz", Bravos: map[string]*cmp_test.CycleBravo{ "BarBuzzBravo": &⟪ref#1⟫{ID: 102, Name: "BarBuzzBravo", Mods: 2, Alphas: {"Bar": &⟪ref#0⟫(...), "Buzz": &⟪ref#2⟫(...)}}, - "BuzzBarBravo": &{ID: 103, Name: "BuzzBarBravo"}, + "BuzzBarBravo": &⟪ref#3⟫(...), }, }, }, }, }, }, "Buzz": &⟪ref#2⟫{ Name: "Buzz", Bravos: map[string]*cmp_test.CycleBravo{ "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⟫(...)}}, "BuzzBarBravo": &⟪ref#3⟫{ ID: 103, Name: "BuzzBarBravo", Mods: 0, - Alphas: nil, + Alphas: map[string]*cmp_test.CycleAlpha{ + "Bar": &⟪ref#0⟫{ + Name: "Bar", + Bravos: map[string]*cmp_test.CycleBravo{"BarBuzzBravo": &⟪ref#1⟫{...}, "BuzzBarBravo": &⟪ref#3⟫(...)}, + }, + "Buzz": &⟪ref#2⟫(...), + }, }, }, }, "Foo": &⟪ref#4⟫{Name: "Foo", Bravos: {"FooBravo": &{ID: 101, Name: "FooBravo", Mods: 100, Alphas: {"Foo": &⟪ref#4⟫(...)}}}}, } >>> TestDiff/Cycle/GraphInequalStruct <<< TestDiff/Project1/ProtoInequal teststructs.Eagle{ ... // 4 identical fields Dreamers: nil, Prong: 0, Slaps: []teststructs.Slap{ ... // 2 identical elements {}, {}, { Name: "", Desc: "", DescLong: "", - Args: s"metadata", + Args: s"metadata2", Tense: 0, Interval: 0, ... // 3 identical fields }, }, StateGoverner: "", PrankRating: "", ... // 2 identical fields } >>> TestDiff/Project1/ProtoInequal <<< TestDiff/Project1/Inequal teststructs.Eagle{ ... // 2 identical fields Desc: "some description", DescLong: "", Dreamers: []teststructs.Dreamer{ {}, { ... // 4 identical fields ContSlaps: nil, ContSlapsInterval: 0, Animal: []interface{}{ teststructs.Goat{ Target: "corporation", Slaps: nil, FunnyPrank: "", Immutable: &teststructs.GoatImmutable{ - ID: "southbay2", + ID: "southbay", - State: &6, + State: &5, Started: s"2009-11-10 23:00:00 +0000 UTC", Stopped: s"0001-01-01 00:00:00 +0000 UTC", ... // 1 ignored and 1 identical fields }, }, teststructs.Donkey{}, }, Ornamental: false, Amoeba: 53, ... // 5 identical fields }, }, Prong: 0, Slaps: []teststructs.Slap{ { ... // 6 identical fields Homeland: 0, FunnyPrank: "", Immutable: &teststructs.SlapImmutable{ ID: "immutableSlap", Out: nil, - MildSlap: false, + MildSlap: true, PrettyPrint: "", State: nil, Started: s"2009-11-10 23:00:00 +0000 UTC", Stopped: s"0001-01-01 00:00:00 +0000 UTC", LastUpdate: s"0001-01-01 00:00:00 +0000 UTC", LoveRadius: &teststructs.LoveRadius{ Summer: &teststructs.SummerLove{ Summary: &teststructs.SummerLoveSummary{ Devices: []string{ "foo", - "bar", - "baz", }, ChangeType: {1, 2, 3}, ... // 1 ignored field }, ... // 1 ignored field }, ... // 1 ignored field }, ... // 1 ignored field }, }, }, StateGoverner: "", PrankRating: "", ... // 2 identical fields } >>> TestDiff/Project1/Inequal <<< TestDiff/Project2/InequalOrder teststructs.GermBatch{ DirtyGerms: map[int32][]*testprotos.Germ{ 17: {s"germ1"}, 18: { - s"germ2", s"germ3", s"germ4", + s"germ2", }, }, CleanGerms: nil, GermMap: {13: s"germ13", 21: s"germ21"}, ... // 7 identical fields } >>> TestDiff/Project2/InequalOrder <<< TestDiff/Project2/Inequal teststructs.GermBatch{ DirtyGerms: map[int32][]*testprotos.Germ{ + 17: {s"germ1"}, 18: Inverse(Sort, []*testprotos.Germ{ s"germ2", s"germ3", - s"germ4", }), }, CleanGerms: nil, GermMap: {13: s"germ13", 21: s"germ21"}, DishMap: map[int32]*teststructs.Dish{ 0: &{err: e"EOF"}, - 1: nil, + 1: &{err: e"unexpected EOF"}, 2: &{pb: s"dish"}, }, HasPreviousResult: true, DirtyID: 10, CleanID: 0, - GermStrain: 421, + GermStrain: 22, TotalDirtyGerms: 0, InfectedAt: s"2009-11-10 23:00:00 +0000 UTC", } >>> TestDiff/Project2/Inequal <<< TestDiff/Project3/Inequal teststructs.Dirt{ - table: &teststructs.MockTable{state: []string{"a", "c"}}, + table: &teststructs.MockTable{state: []string{"a", "b", "c"}}, ts: 12345, - Discord: 554, + Discord: 500, - Proto: testprotos.Dirt(Inverse(λ, s"blah")), + Proto: testprotos.Dirt(Inverse(λ, s"proto")), wizard: map[string]*testprotos.Wizard{ - "albus": s"dumbledore", - "harry": s"potter", + "harry": s"otter", }, sadistic: nil, lastTime: 54321, ... // 1 ignored field } >>> TestDiff/Project3/Inequal <<< TestDiff/Project4/Inequal teststructs.Cartel{ Headquarter: teststructs.Headquarter{ id: 5, location: "moon", subDivisions: []string{ - "alpha", "bravo", "charlie", }, incorporatedDate: s"0001-01-01 00:00:00 +0000 UTC", metaData: s"metadata", privateMessage: nil, publicMessage: []uint8{ 0x01, 0x02, - 0x03, + 0x04, - 0x04, + 0x03, 0x05, }, horseBack: "abcdef", rattle: "", ... // 5 identical fields }, source: "mars", creationDate: s"0001-01-01 00:00:00 +0000 UTC", boss: "al capone", lastCrimeDate: s"0001-01-01 00:00:00 +0000 UTC", poisons: []*teststructs.Poison{ &{ - poisonType: 1, + poisonType: 5, expiration: s"2009-11-10 23:00:00 +0000 UTC", manufacturer: "acme", potency: 0, }, - &{poisonType: 2, manufacturer: "acme2"}, }, } >>> TestDiff/Project4/Inequal