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
View as plain text