|
<<< 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 |
|
[32]uint8{ |
|
- 0xca, 0x97, 0x81, 0x12, 0xca, 0x1b, 0xbd, 0xca, 0xfa, 0xc2, 0x31, 0xb3, 0x9a, 0x23, 0xdc, 0x4d, |
|
- 0xa7, 0x86, 0xef, 0xf8, 0x14, 0x7c, 0x4e, 0x72, 0xb9, 0x80, 0x77, 0x85, 0xaf, 0xee, 0x48, 0xbb, |
|
+ 0x3e, 0x23, 0xe8, 0x16, 0x00, 0x39, 0x59, 0x4a, 0x33, 0x89, 0x4f, 0x65, 0x64, 0xe1, 0xb1, 0x34, |
|
+ 0x8b, 0xbd, 0x7a, 0x00, 0x88, 0xd4, 0x2c, 0x4a, 0xcb, 0x73, 0xee, 0xae, 0xd5, 0x9c, 0x00, 0x9d, |
|
} |
|
>>> TestDiff/Comparer/DifferingHash |
|
<<< TestDiff/Comparer/NilStringer |
|
any( |
|
- &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 |
|
any( |
|
- []*testprotos.Stringer{s`multi\nline\nline\nline`}, |
|
) |
|
>>> TestDiff/Comparer/StringerBacktick |
|
<<< TestDiff/Comparer/DynamicMap |
|
[]any{ |
|
map[string]any{ |
|
"avg": float64(0.278), |
|
- "hr": int(65), |
|
+ "hr": float64(65), |
|
"name": string("Mark McGwire"), |
|
}, |
|
map[string]any{ |
|
"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(λ, any( |
|
- string("zero"), |
|
+ float64(1), |
|
))) |
|
>>> TestDiff/Transformer/DisjointOutput |
|
<<< TestDiff/Transformer/JSON |
|
string(Inverse(ParseJSON, map[string]any{ |
|
"address": map[string]any{ |
|
- "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": []any{}, |
|
"firstName": string("John"), |
|
"isAlive": bool(true), |
|
"lastName": string("Smith"), |
|
"phoneNumbers": []any{ |
|
map[string]any{ |
|
- "number": string("212 555-4321"), |
|
+ "number": string("212 555-1234"), |
|
"type": string("home"), |
|
}, |
|
map[string]any{"number": string("646 555-4567"), "type": string("office")}, |
|
map[string]any{"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{ |
|
"some", |
|
"multi", |
|
"line", |
|
{ |
|
- 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 |
|
any( |
|
- "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 |
|
any( |
|
- 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[any]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[any]string{ |
|
+ s"fizz": "buzz", |
|
- s"hello": "goodbye", |
|
} |
|
>>> TestDiff/Reporter/NonAmbiguousStringerMapKey |
|
<<< TestDiff/Reporter/InvalidUTF8 |
|
any( |
|
- 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 |
|
any( |
|
- 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/Reporter/LargeMapKey |
|
map[*[]uint8]int{ |
|
- &⟪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, |
|
+ &⟪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, |
|
} |
|
>>> TestDiff/Reporter/LargeMapKey |
|
<<< TestDiff/Reporter/LargeStringInInterface |
|
struct{ X any }{ |
|
X: strings.Join({ |
|
... // 485 identical bytes |
|
"s mus. Pellentesque mi lorem, consectetur id porttitor id, solli", |
|
"citudin sit amet enim. Duis eu dolor magna. Nunc ut augue turpis", |
|
- ".", |
|
+ ",", |
|
}, ""), |
|
} |
|
>>> TestDiff/Reporter/LargeStringInInterface |
|
<<< TestDiff/Reporter/LargeBytesInInterface |
|
struct{ X any }{ |
|
X: bytes.Join({ |
|
... // 485 identical bytes |
|
"s mus. Pellentesque mi lorem, consectetur id porttitor id, solli", |
|
"citudin sit amet enim. Duis eu dolor magna. Nunc ut augue turpis", |
|
- ".", |
|
+ ",", |
|
}, ""), |
|
} |
|
>>> TestDiff/Reporter/LargeBytesInInterface |
|
<<< TestDiff/Reporter/LargeStandaloneString |
|
struct{ X any }{ |
|
- X: [1]string{ |
|
- "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.", |
|
- }, |
|
+ X: [1]string{ |
|
+ "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,", |
|
+ }, |
|
} |
|
>>> TestDiff/Reporter/LargeStandaloneString |
|
<<< TestDiff/Reporter/SurroundingEqualElements |
|
strings.Join({ |
|
"org-4747474747474747,bucket-4242424242424242:m,tag1=a,tag2=aa", |
|
- ",#=_value", |
|
` _value=2 11 org-4747474747474747,bucket-4242424242424242:m,tag1`, |
|
"=a,tag2=bb", |
|
- ",#=_value", |
|
` _value=2 21 org-4747474747474747,bucket-4242424242424242:m,tag1`, |
|
"=b,tag2=cc", |
|
- ",#=_value", |
|
` _value=1 21 org-4747474747474747,bucket-4242424242424242:m,tag1`, |
|
"=a,tag2=dd", |
|
- ",#=_value", |
|
` _value=3 31 org-4747474747474747,bucket-4242424242424242:m,tag1`, |
|
"=c", |
|
- ",#=_value", |
|
` _value=4 41 `, |
|
}, "") |
|
>>> TestDiff/Reporter/SurroundingEqualElements |
|
<<< TestDiff/Reporter/MostlyTextString |
|
strings.Join({ |
|
"org-4747474747474747,bucket-4242424242424242:m,tag1=a,tag2=aa", |
|
- ",\xff=_value", |
|
" _value=2 11\norg-4747474747474747,bucket-4242424242424242:m,tag1", |
|
"=a,tag2=bb", |
|
- ",\xff=_value", |
|
" _value=2 21\norg-4747474747474747,bucket-4242424242424242:m,tag1", |
|
"=b,tag2=cc", |
|
- ",\xff=_value", |
|
" _value=1 21\norg-4747474747474747,bucket-4242424242424242:m,tag1", |
|
"=a,tag2=dd", |
|
- ",\xff=_value", |
|
" _value=3 31\norg-4747474747474747,bucket-4242424242424242:m,tag1", |
|
"=c", |
|
- ",\xff=_value", |
|
" _value=4 41\n", |
|
}, "") |
|
>>> TestDiff/Reporter/MostlyTextString |
|
<<< TestDiff/Reporter/AllLinesDiffer |
|
strings.Join({ |
|
+ "X", |
|
"d5c14bdf6bac81c27afc5429500ed750\n", |
|
+ "X", |
|
"25483503b557c606dad4f144d27ae10b\n", |
|
+ "X", |
|
"90bdbcdbb6ea7156068e3dcfb7459244\n", |
|
+ "X", |
|
"978f480a6e3cced51e297fbff9a506b7\n", |
|
}, "") |
|
>>> TestDiff/Reporter/AllLinesDiffer |
|
<<< TestDiff/Reporter/StringifiedBytes |
|
struct{ X []uint8 }{ |
|
- X: []uint8("hello, world!"), |
|
+ X: nil, |
|
} |
|
>>> TestDiff/Reporter/StringifiedBytes |
|
<<< TestDiff/Reporter/NonStringifiedBytes |
|
struct{ X []uint8 }{ |
|
- X: []uint8{0xde, 0xad, 0xbe, 0xef}, |
|
+ X: nil, |
|
} |
|
>>> TestDiff/Reporter/NonStringifiedBytes |
|
<<< TestDiff/Reporter/StringifiedNamedBytes |
|
struct{ X cmp_test.MyBytes }{ |
|
- X: cmp_test.MyBytes("hello, world!"), |
|
+ X: nil, |
|
} |
|
>>> TestDiff/Reporter/StringifiedNamedBytes |
|
<<< TestDiff/Reporter/NonStringifiedNamedBytes |
|
struct{ X cmp_test.MyBytes }{ |
|
- X: cmp_test.MyBytes{0xde, 0xad, 0xbe, 0xef}, |
|
+ X: nil, |
|
} |
|
>>> TestDiff/Reporter/NonStringifiedNamedBytes |
|
<<< TestDiff/Reporter/ShortJSON |
|
( |
|
""" |
|
{ |
|
- "id": 1, |
|
+ "id": 1434180, |
|
"foo": true, |
|
"bar": true, |
|
} |
|
""" |
|
) |
|
>>> TestDiff/Reporter/ShortJSON |
|
<<< TestDiff/Reporter/PointerToStringOrAny |
|
any( |
|
- &string("hello"), |
|
+ &any(string("hello")), |
|
) |
|
>>> TestDiff/Reporter/PointerToStringOrAny |
|
<<< TestDiff/Reporter/NamedPointer |
|
any( |
|
- &string("hello"), |
|
+ cmp_test.PointerString(&string("hello")), |
|
) |
|
>>> TestDiff/Reporter/NamedPointer |
|
<<< TestDiff/Reporter/MapStringAny |
|
map[string]any{ |
|
- "key": int(0), |
|
+ "key": uint(0), |
|
} |
|
>>> TestDiff/Reporter/MapStringAny |
|
<<< TestDiff/Reporter/StructFieldAny |
|
struct{ X any }{ |
|
- X: int(0), |
|
+ X: uint(0), |
|
} |
|
>>> TestDiff/Reporter/StructFieldAny |
|
<<< TestDiff/Reporter/SliceOfBytesText |
|
[][]uint8{ |
|
- "hello", |
|
"foo", |
|
+ "foo", |
|
"barbaz", |
|
+ "added", |
|
+ "here", |
|
- "blahdieblah", |
|
+ "hrmph", |
|
} |
|
>>> TestDiff/Reporter/SliceOfBytesText |
|
<<< TestDiff/Reporter/SliceOfBytesBinary |
|
[][]uint8{ |
|
- {0xde, 0xad, 0xbe, 0xef}, |
|
{0xff, 0x6f, 0x6f}, |
|
+ "foo", |
|
"barbaz", |
|
+ "added", |
|
+ "here", |
|
- "blahdieblah", |
|
+ {0x68, 0x72, 0x6d, 0x70, 0x68, 0xff}, |
|
} |
|
>>> TestDiff/Reporter/SliceOfBytesBinary |
|
<<< TestDiff/Reporter/ManyEscapeCharacters |
|
( |
|
""" |
|
[ |
|
- {"Base32": "NA======"}, |
|
+ {"Base32": "NB======"}, |
|
{"Base32": "NBSQ===="}, |
|
{"Base32": "NBSWY==="}, |
|
... // 3 identical lines |
|
""" |
|
) |
|
>>> TestDiff/Reporter/ManyEscapeCharacters |
|
<<< 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: []any{ |
|
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 |
