| // Copyright 2017, The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package cmpopts |
| |
| import ( |
| "bytes" |
| "errors" |
| "fmt" |
| "io" |
| "math" |
| "net/netip" |
| "reflect" |
| "strings" |
| "sync" |
| "testing" |
| "time" |
| |
| "github.com/google/go-cmp/cmp" |
| ) |
| |
| type ( |
| MyInt int |
| MyInts []int |
| MyFloat float32 |
| MyString string |
| MyTime struct{ time.Time } |
| MyStruct struct { |
| A, B []int |
| C, D map[time.Time]string |
| } |
| |
| Foo1 struct{ Alpha, Bravo, Charlie int } |
| Foo2 struct{ *Foo1 } |
| Foo3 struct{ *Foo2 } |
| Bar1 struct{ Foo3 } |
| Bar2 struct { |
| Bar1 |
| *Foo3 |
| Bravo float32 |
| } |
| Bar3 struct { |
| Bar1 |
| Bravo *Bar2 |
| Delta struct{ Echo Foo1 } |
| *Foo3 |
| Alpha string |
| } |
| |
| privateStruct struct{ Public, private int } |
| PublicStruct struct{ Public, private int } |
| ParentStruct struct { |
| *privateStruct |
| *PublicStruct |
| Public int |
| private int |
| } |
| |
| Everything struct { |
| MyInt |
| MyFloat |
| MyTime |
| MyStruct |
| Bar3 |
| ParentStruct |
| } |
| |
| EmptyInterface interface{} |
| ) |
| |
| func TestOptions(t *testing.T) { |
| createBar3X := func() *Bar3 { |
| return &Bar3{ |
| Bar1: Bar1{Foo3{&Foo2{&Foo1{Bravo: 2}}}}, |
| Bravo: &Bar2{ |
| Bar1: Bar1{Foo3{&Foo2{&Foo1{Charlie: 7}}}}, |
| Foo3: &Foo3{&Foo2{&Foo1{Bravo: 5}}}, |
| Bravo: 4, |
| }, |
| Delta: struct{ Echo Foo1 }{Foo1{Charlie: 3}}, |
| Foo3: &Foo3{&Foo2{&Foo1{Alpha: 1}}}, |
| Alpha: "alpha", |
| } |
| } |
| createBar3Y := func() *Bar3 { |
| return &Bar3{ |
| Bar1: Bar1{Foo3{&Foo2{&Foo1{Bravo: 3}}}}, |
| Bravo: &Bar2{ |
| Bar1: Bar1{Foo3{&Foo2{&Foo1{Charlie: 8}}}}, |
| Foo3: &Foo3{&Foo2{&Foo1{Bravo: 6}}}, |
| Bravo: 5, |
| }, |
| Delta: struct{ Echo Foo1 }{Foo1{Charlie: 4}}, |
| Foo3: &Foo3{&Foo2{&Foo1{Alpha: 2}}}, |
| Alpha: "ALPHA", |
| } |
| } |
| |
| tests := []struct { |
| label string // Test name |
| x, y interface{} // Input values to compare |
| opts []cmp.Option // Input options |
| wantEqual bool // Whether the inputs are equal |
| wantPanic bool // Whether Equal should panic |
| reason string // The reason for the expected outcome |
| }{{ |
| label: "EquateEmpty", |
| x: []int{}, |
| y: []int(nil), |
| wantEqual: false, |
| reason: "not equal because empty non-nil and nil slice differ", |
| }, { |
| label: "EquateEmpty", |
| x: []int{}, |
| y: []int(nil), |
| opts: []cmp.Option{EquateEmpty()}, |
| wantEqual: true, |
| reason: "equal because EquateEmpty equates empty slices", |
| }, { |
| label: "SortSlices", |
| x: []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, |
| y: []int{1, 0, 5, 2, 8, 9, 4, 3, 6, 7}, |
| wantEqual: false, |
| reason: "not equal because element order differs", |
| }, { |
| label: "SortSlices", |
| x: []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, |
| y: []int{1, 0, 5, 2, 8, 9, 4, 3, 6, 7}, |
| opts: []cmp.Option{SortSlices(func(x, y int) bool { return x < y })}, |
| wantEqual: true, |
| reason: "equal because SortSlices sorts the slices", |
| }, { |
| label: "SortSlices", |
| x: []MyInt{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, |
| y: []MyInt{1, 0, 5, 2, 8, 9, 4, 3, 6, 7}, |
| opts: []cmp.Option{SortSlices(func(x, y int) bool { return x < y })}, |
| wantEqual: false, |
| reason: "not equal because MyInt is not the same type as int", |
| }, { |
| label: "SortSlices", |
| x: []float64{0, 1, 1, 2, 2, 2}, |
| y: []float64{2, 0, 2, 1, 2, 1}, |
| opts: []cmp.Option{SortSlices(func(x, y float64) bool { return x < y })}, |
| wantEqual: true, |
| reason: "equal even when sorted with duplicate elements", |
| }, { |
| label: "SortSlices", |
| x: []float64{0, 1, 1, 2, 2, 2, math.NaN(), 3, 3, 3, 3, 4, 4, 4, 4}, |
| y: []float64{2, 0, 4, 4, 3, math.NaN(), 4, 1, 3, 2, 3, 3, 4, 1, 2}, |
| opts: []cmp.Option{SortSlices(func(x, y float64) bool { return x < y })}, |
| wantPanic: true, |
| reason: "panics because SortSlices used with non-transitive less function", |
| }, { |
| label: "SortSlices", |
| x: []float64{0, 1, 1, 2, 2, 2, math.NaN(), 3, 3, 3, 3, 4, 4, 4, 4}, |
| y: []float64{2, 0, 4, 4, 3, math.NaN(), 4, 1, 3, 2, 3, 3, 4, 1, 2}, |
| opts: []cmp.Option{SortSlices(func(x, y float64) bool { |
| return (!math.IsNaN(x) && math.IsNaN(y)) || x < y |
| })}, |
| wantEqual: false, |
| reason: "no panics because SortSlices used with valid less function; not equal because NaN != NaN", |
| }, { |
| label: "SortSlices+EquateNaNs", |
| x: []float64{0, 1, 1, 2, 2, 2, math.NaN(), 3, 3, 3, math.NaN(), 3, 4, 4, 4, 4}, |
| y: []float64{2, 0, 4, 4, 3, math.NaN(), 4, 1, 3, 2, 3, 3, 4, 1, math.NaN(), 2}, |
| opts: []cmp.Option{ |
| EquateNaNs(), |
| SortSlices(func(x, y float64) bool { |
| return (!math.IsNaN(x) && math.IsNaN(y)) || x < y |
| }), |
| }, |
| wantEqual: true, |
| reason: "no panics because SortSlices used with valid less function; equal because EquateNaNs is used", |
| }, { |
| label: "SortMaps", |
| x: map[time.Time]string{ |
| time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC): "0th birthday", |
| time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC): "1st birthday", |
| time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC): "2nd birthday", |
| }, |
| y: map[time.Time]string{ |
| time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "0th birthday", |
| time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "1st birthday", |
| time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "2nd birthday", |
| }, |
| wantEqual: false, |
| reason: "not equal because timezones differ", |
| }, { |
| label: "SortMaps", |
| x: map[time.Time]string{ |
| time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC): "0th birthday", |
| time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC): "1st birthday", |
| time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC): "2nd birthday", |
| }, |
| y: map[time.Time]string{ |
| time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "0th birthday", |
| time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "1st birthday", |
| time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "2nd birthday", |
| }, |
| opts: []cmp.Option{SortMaps(func(x, y time.Time) bool { return x.Before(y) })}, |
| wantEqual: true, |
| reason: "equal because SortMaps flattens to a slice where Time.Equal can be used", |
| }, { |
| label: "SortMaps", |
| x: map[MyTime]string{ |
| {time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)}: "0th birthday", |
| {time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC)}: "1st birthday", |
| {time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC)}: "2nd birthday", |
| }, |
| y: map[MyTime]string{ |
| {time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local)}: "0th birthday", |
| {time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local)}: "1st birthday", |
| {time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local)}: "2nd birthday", |
| }, |
| opts: []cmp.Option{SortMaps(func(x, y time.Time) bool { return x.Before(y) })}, |
| wantEqual: false, |
| reason: "not equal because MyTime is not assignable to time.Time", |
| }, { |
| label: "SortMaps", |
| x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""}, |
| // => {0, 1, 2, 3, -1, -2, -3}, |
| y: map[int]string{300: "", 200: "", 100: "", 0: "", 1: "", 2: "", 3: ""}, |
| // => {0, 1, 2, 3, 100, 200, 300}, |
| opts: []cmp.Option{SortMaps(func(a, b int) bool { |
| if -10 < a && a <= 0 { |
| a *= -100 |
| } |
| if -10 < b && b <= 0 { |
| b *= -100 |
| } |
| return a < b |
| })}, |
| wantEqual: false, |
| reason: "not equal because values differ even though SortMap provides valid ordering", |
| }, { |
| label: "SortMaps", |
| x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""}, |
| // => {0, 1, 2, 3, -1, -2, -3}, |
| y: map[int]string{300: "", 200: "", 100: "", 0: "", 1: "", 2: "", 3: ""}, |
| // => {0, 1, 2, 3, 100, 200, 300}, |
| opts: []cmp.Option{ |
| SortMaps(func(x, y int) bool { |
| if -10 < x && x <= 0 { |
| x *= -100 |
| } |
| if -10 < y && y <= 0 { |
| y *= -100 |
| } |
| return x < y |
| }), |
| cmp.Comparer(func(x, y int) bool { |
| if -10 < x && x <= 0 { |
| x *= -100 |
| } |
| if -10 < y && y <= 0 { |
| y *= -100 |
| } |
| return x == y |
| }), |
| }, |
| wantEqual: true, |
| reason: "equal because Comparer used to equate differences", |
| }, { |
| label: "SortMaps", |
| x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""}, |
| y: map[int]string{}, |
| opts: []cmp.Option{SortMaps(func(x, y int) bool { |
| return x < y && x >= 0 && y >= 0 |
| })}, |
| wantPanic: true, |
| reason: "panics because SortMaps used with non-transitive less function", |
| }, { |
| label: "SortMaps", |
| x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""}, |
| y: map[int]string{}, |
| opts: []cmp.Option{SortMaps(func(x, y int) bool { |
| return math.Abs(float64(x)) < math.Abs(float64(y)) |
| })}, |
| wantPanic: true, |
| reason: "panics because SortMaps used with partial less function", |
| }, { |
| label: "EquateEmpty+SortSlices+SortMaps", |
| x: MyStruct{ |
| A: []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, |
| C: map[time.Time]string{ |
| time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC): "0th birthday", |
| time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC): "1st birthday", |
| }, |
| D: map[time.Time]string{}, |
| }, |
| y: MyStruct{ |
| A: []int{1, 0, 5, 2, 8, 9, 4, 3, 6, 7}, |
| B: []int{}, |
| C: map[time.Time]string{ |
| time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "0th birthday", |
| time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "1st birthday", |
| }, |
| }, |
| opts: []cmp.Option{ |
| EquateEmpty(), |
| SortSlices(func(x, y int) bool { return x < y }), |
| SortMaps(func(x, y time.Time) bool { return x.Before(y) }), |
| }, |
| wantEqual: true, |
| reason: "no panics because EquateEmpty should compose with the sort options", |
| }, { |
| label: "EquateApprox", |
| x: 3.09, |
| y: 3.10, |
| wantEqual: false, |
| reason: "not equal because floats do not exactly matches", |
| }, { |
| label: "EquateApprox", |
| x: 3.09, |
| y: 3.10, |
| opts: []cmp.Option{EquateApprox(0, 0)}, |
| wantEqual: false, |
| reason: "not equal because EquateApprox(0 ,0) is equivalent to using ==", |
| }, { |
| label: "EquateApprox", |
| x: 3.09, |
| y: 3.10, |
| opts: []cmp.Option{EquateApprox(0.003, 0.009)}, |
| wantEqual: false, |
| reason: "not equal because EquateApprox is too strict", |
| }, { |
| label: "EquateApprox", |
| x: 3.09, |
| y: 3.10, |
| opts: []cmp.Option{EquateApprox(0, 0.011)}, |
| wantEqual: true, |
| reason: "equal because margin is loose enough to match", |
| }, { |
| label: "EquateApprox", |
| x: 3.09, |
| y: 3.10, |
| opts: []cmp.Option{EquateApprox(0.004, 0)}, |
| wantEqual: true, |
| reason: "equal because fraction is loose enough to match", |
| }, { |
| label: "EquateApprox", |
| x: 3.09, |
| y: 3.10, |
| opts: []cmp.Option{EquateApprox(0.004, 0.011)}, |
| wantEqual: true, |
| reason: "equal because both the margin and fraction are loose enough to match", |
| }, { |
| label: "EquateApprox", |
| x: float32(3.09), |
| y: float64(3.10), |
| opts: []cmp.Option{EquateApprox(0.004, 0)}, |
| wantEqual: false, |
| reason: "not equal because the types differ", |
| }, { |
| label: "EquateApprox", |
| x: float32(3.09), |
| y: float32(3.10), |
| opts: []cmp.Option{EquateApprox(0.004, 0)}, |
| wantEqual: true, |
| reason: "equal because EquateApprox also applies on float32s", |
| }, { |
| label: "EquateApprox", |
| x: []float64{math.Inf(+1), math.Inf(-1)}, |
| y: []float64{math.Inf(+1), math.Inf(-1)}, |
| opts: []cmp.Option{EquateApprox(0, 1)}, |
| wantEqual: true, |
| reason: "equal because we fall back on == which matches Inf (EquateApprox does not apply on Inf) ", |
| }, { |
| label: "EquateApprox", |
| x: []float64{math.Inf(+1), -1e100}, |
| y: []float64{+1e100, math.Inf(-1)}, |
| opts: []cmp.Option{EquateApprox(0, 1)}, |
| wantEqual: false, |
| reason: "not equal because we fall back on == where Inf != 1e100 (EquateApprox does not apply on Inf)", |
| }, { |
| label: "EquateApprox", |
| x: float64(+1e100), |
| y: float64(-1e100), |
| opts: []cmp.Option{EquateApprox(math.Inf(+1), 0)}, |
| wantEqual: true, |
| reason: "equal because infinite fraction matches everything", |
| }, { |
| label: "EquateApprox", |
| x: float64(+1e100), |
| y: float64(-1e100), |
| opts: []cmp.Option{EquateApprox(0, math.Inf(+1))}, |
| wantEqual: true, |
| reason: "equal because infinite margin matches everything", |
| }, { |
| label: "EquateApprox", |
| x: math.Pi, |
| y: math.Pi, |
| opts: []cmp.Option{EquateApprox(0, 0)}, |
| wantEqual: true, |
| reason: "equal because EquateApprox(0, 0) is equivalent to ==", |
| }, { |
| label: "EquateApprox", |
| x: math.Pi, |
| y: math.Nextafter(math.Pi, math.Inf(+1)), |
| opts: []cmp.Option{EquateApprox(0, 0)}, |
| wantEqual: false, |
| reason: "not equal because EquateApprox(0, 0) is equivalent to ==", |
| }, { |
| label: "EquateNaNs", |
| x: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)}, |
| y: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)}, |
| wantEqual: false, |
| reason: "not equal because NaN != NaN", |
| }, { |
| label: "EquateNaNs", |
| x: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)}, |
| y: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)}, |
| opts: []cmp.Option{EquateNaNs()}, |
| wantEqual: true, |
| reason: "equal because EquateNaNs allows NaN == NaN", |
| }, { |
| label: "EquateNaNs", |
| x: []float32{1.0, float32(math.NaN()), math.E, -0.0, +0.0}, |
| y: []float32{1.0, float32(math.NaN()), math.E, -0.0, +0.0}, |
| opts: []cmp.Option{EquateNaNs()}, |
| wantEqual: true, |
| reason: "equal because EquateNaNs operates on float32", |
| }, { |
| label: "EquateApprox+EquateNaNs", |
| x: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1), 1.01, 5001}, |
| y: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1), 1.02, 5002}, |
| opts: []cmp.Option{ |
| EquateNaNs(), |
| EquateApprox(0.01, 0), |
| }, |
| wantEqual: true, |
| reason: "equal because EquateNaNs and EquateApprox compose together", |
| }, { |
| label: "EquateApprox+EquateNaNs", |
| x: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.01, 5001}, |
| y: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.02, 5002}, |
| opts: []cmp.Option{ |
| EquateNaNs(), |
| EquateApprox(0.01, 0), |
| }, |
| wantEqual: false, |
| reason: "not equal because EquateApprox and EquateNaNs do not apply on a named type", |
| }, { |
| label: "EquateApprox+EquateNaNs+Transform", |
| x: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.01, 5001}, |
| y: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.02, 5002}, |
| opts: []cmp.Option{ |
| cmp.Transformer("", func(x MyFloat) float64 { return float64(x) }), |
| EquateNaNs(), |
| EquateApprox(0.01, 0), |
| }, |
| wantEqual: true, |
| reason: "equal because named type is transformed to float64", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), |
| y: time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), |
| opts: []cmp.Option{EquateApproxTime(0)}, |
| wantEqual: true, |
| reason: "equal because times are identical", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), |
| y: time.Date(2009, 11, 10, 23, 0, 3, 0, time.UTC), |
| opts: []cmp.Option{EquateApproxTime(3 * time.Second)}, |
| wantEqual: true, |
| reason: "equal because time is exactly at the allowed margin", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Date(2009, 11, 10, 23, 0, 3, 0, time.UTC), |
| y: time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), |
| opts: []cmp.Option{EquateApproxTime(3 * time.Second)}, |
| wantEqual: true, |
| reason: "equal because time is exactly at the allowed margin (negative)", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Date(2009, 11, 10, 23, 0, 3, 0, time.UTC), |
| y: time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), |
| opts: []cmp.Option{EquateApproxTime(3*time.Second - 1)}, |
| wantEqual: false, |
| reason: "not equal because time is outside allowed margin", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), |
| y: time.Date(2009, 11, 10, 23, 0, 3, 0, time.UTC), |
| opts: []cmp.Option{EquateApproxTime(3*time.Second - 1)}, |
| wantEqual: false, |
| reason: "not equal because time is outside allowed margin (negative)", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Time{}, |
| y: time.Time{}, |
| opts: []cmp.Option{EquateApproxTime(3 * time.Second)}, |
| wantEqual: true, |
| reason: "equal because both times are zero", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Time{}, |
| y: time.Time{}.Add(1), |
| opts: []cmp.Option{EquateApproxTime(3 * time.Second)}, |
| wantEqual: false, |
| reason: "not equal because zero time is always not equal not non-zero", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Time{}.Add(1), |
| y: time.Time{}, |
| opts: []cmp.Option{EquateApproxTime(3 * time.Second)}, |
| wantEqual: false, |
| reason: "not equal because zero time is always not equal not non-zero", |
| }, { |
| label: "EquateApproxTime", |
| x: time.Date(2409, 11, 10, 23, 0, 0, 0, time.UTC), |
| y: time.Date(2000, 11, 10, 23, 0, 3, 0, time.UTC), |
| opts: []cmp.Option{EquateApproxTime(3 * time.Second)}, |
| wantEqual: false, |
| reason: "time difference overflows time.Duration", |
| }, { |
| label: "EquateErrors", |
| x: nil, |
| y: nil, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "nil values are equal", |
| }, { |
| label: "EquateErrors", |
| x: errors.New("EOF"), |
| y: io.EOF, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: false, |
| reason: "user-defined EOF is not exactly equal", |
| }, { |
| label: "EquateErrors", |
| x: fmt.Errorf("wrapped: %w", io.EOF), |
| y: io.EOF, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "wrapped io.EOF is equal according to errors.Is", |
| }, { |
| label: "EquateErrors", |
| x: fmt.Errorf("wrapped: %w", io.EOF), |
| y: io.EOF, |
| wantEqual: false, |
| reason: "wrapped io.EOF is not equal without EquateErrors option", |
| }, { |
| label: "EquateErrors", |
| x: io.EOF, |
| y: io.EOF, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "sentinel errors are equal", |
| }, { |
| label: "EquateErrors", |
| x: io.EOF, |
| y: AnyError, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "AnyError is equal to any non-nil error", |
| }, { |
| label: "EquateErrors", |
| x: io.EOF, |
| y: AnyError, |
| wantEqual: false, |
| reason: "AnyError is not equal to any non-nil error without EquateErrors option", |
| }, { |
| label: "EquateErrors", |
| x: nil, |
| y: AnyError, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: false, |
| reason: "AnyError is not equal to nil value", |
| }, { |
| label: "EquateErrors", |
| x: nil, |
| y: nil, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "nil values are equal", |
| }, { |
| label: "EquateErrors", |
| x: errors.New("EOF"), |
| y: io.EOF, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: false, |
| reason: "user-defined EOF is not exactly equal", |
| }, { |
| label: "EquateErrors", |
| x: fmt.Errorf("wrapped: %w", io.EOF), |
| y: io.EOF, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "wrapped io.EOF is equal according to errors.Is", |
| }, { |
| label: "EquateErrors", |
| x: fmt.Errorf("wrapped: %w", io.EOF), |
| y: io.EOF, |
| wantEqual: false, |
| reason: "wrapped io.EOF is not equal without EquateErrors option", |
| }, { |
| label: "EquateErrors", |
| x: io.EOF, |
| y: io.EOF, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "sentinel errors are equal", |
| }, { |
| label: "EquateErrors", |
| x: io.EOF, |
| y: AnyError, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "AnyError is equal to any non-nil error", |
| }, { |
| label: "EquateErrors", |
| x: io.EOF, |
| y: AnyError, |
| wantEqual: false, |
| reason: "AnyError is not equal to any non-nil error without EquateErrors option", |
| }, { |
| label: "EquateErrors", |
| x: nil, |
| y: AnyError, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: false, |
| reason: "AnyError is not equal to nil value", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{nil}, |
| y: struct{ E error }{nil}, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "nil values are equal", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{errors.New("EOF")}, |
| y: struct{ E error }{io.EOF}, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: false, |
| reason: "user-defined EOF is not exactly equal", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{fmt.Errorf("wrapped: %w", io.EOF)}, |
| y: struct{ E error }{io.EOF}, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "wrapped io.EOF is equal according to errors.Is", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{fmt.Errorf("wrapped: %w", io.EOF)}, |
| y: struct{ E error }{io.EOF}, |
| wantEqual: false, |
| reason: "wrapped io.EOF is not equal without EquateErrors option", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{io.EOF}, |
| y: struct{ E error }{io.EOF}, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "sentinel errors are equal", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{io.EOF}, |
| y: struct{ E error }{AnyError}, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: true, |
| reason: "AnyError is equal to any non-nil error", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{io.EOF}, |
| y: struct{ E error }{AnyError}, |
| wantEqual: false, |
| reason: "AnyError is not equal to any non-nil error without EquateErrors option", |
| }, { |
| label: "EquateErrors", |
| x: struct{ E error }{nil}, |
| y: struct{ E error }{AnyError}, |
| opts: []cmp.Option{EquateErrors()}, |
| wantEqual: false, |
| reason: "AnyError is not equal to nil value", |
| }, { |
| label: "EquateComparable", |
| x: []struct{ P netip.Addr }{ |
| {netip.AddrFrom4([4]byte{1, 2, 3, 4})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 5})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 6})}, |
| }, |
| y: []struct{ P netip.Addr }{ |
| {netip.AddrFrom4([4]byte{1, 2, 3, 4})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 5})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 6})}, |
| }, |
| opts: []cmp.Option{EquateComparable(netip.Addr{})}, |
| wantEqual: true, |
| reason: "equal because all IP addresses are the same", |
| }, { |
| label: "EquateComparable", |
| x: []struct{ P netip.Addr }{ |
| {netip.AddrFrom4([4]byte{1, 2, 3, 4})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 5})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 6})}, |
| }, |
| y: []struct{ P netip.Addr }{ |
| {netip.AddrFrom4([4]byte{1, 2, 3, 4})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 7})}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 6})}, |
| }, |
| opts: []cmp.Option{EquateComparable(netip.Addr{})}, |
| wantEqual: false, |
| reason: "not equal because second IP address is different", |
| }, { |
| label: "IgnoreFields", |
| x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}}, |
| y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}}, |
| wantEqual: false, |
| reason: "not equal because values do not match in deeply embedded field", |
| }, { |
| label: "IgnoreFields", |
| x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}}, |
| y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}}, |
| opts: []cmp.Option{IgnoreFields(Bar1{}, "Alpha")}, |
| wantEqual: true, |
| reason: "equal because IgnoreField ignores deeply embedded field: Alpha", |
| }, { |
| label: "IgnoreFields", |
| x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}}, |
| y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}}, |
| opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo1.Alpha")}, |
| wantEqual: true, |
| reason: "equal because IgnoreField ignores deeply embedded field: Foo1.Alpha", |
| }, { |
| label: "IgnoreFields", |
| x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}}, |
| y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}}, |
| opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo2.Alpha")}, |
| wantEqual: true, |
| reason: "equal because IgnoreField ignores deeply embedded field: Foo2.Alpha", |
| }, { |
| label: "IgnoreFields", |
| x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}}, |
| y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}}, |
| opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo3.Alpha")}, |
| wantEqual: true, |
| reason: "equal because IgnoreField ignores deeply embedded field: Foo3.Alpha", |
| }, { |
| label: "IgnoreFields", |
| x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}}, |
| y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}}, |
| opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo3.Foo2.Alpha")}, |
| wantEqual: true, |
| reason: "equal because IgnoreField ignores deeply embedded field: Foo3.Foo2.Alpha", |
| }, { |
| label: "IgnoreFields", |
| x: createBar3X(), |
| y: createBar3Y(), |
| wantEqual: false, |
| reason: "not equal because many deeply nested or embedded fields differ", |
| }, { |
| label: "IgnoreFields", |
| x: createBar3X(), |
| y: createBar3Y(), |
| opts: []cmp.Option{IgnoreFields(Bar3{}, "Bar1", "Bravo", "Delta", "Foo3", "Alpha")}, |
| wantEqual: true, |
| reason: "equal because IgnoreFields ignores fields at the highest levels", |
| }, { |
| label: "IgnoreFields", |
| x: createBar3X(), |
| y: createBar3Y(), |
| opts: []cmp.Option{ |
| IgnoreFields(Bar3{}, |
| "Bar1.Foo3.Bravo", |
| "Bravo.Bar1.Foo3.Foo2.Foo1.Charlie", |
| "Bravo.Foo3.Foo2.Foo1.Bravo", |
| "Bravo.Bravo", |
| "Delta.Echo.Charlie", |
| "Foo3.Foo2.Foo1.Alpha", |
| "Alpha", |
| ), |
| }, |
| wantEqual: true, |
| reason: "equal because IgnoreFields ignores fields using fully-qualified field", |
| }, { |
| label: "IgnoreFields", |
| x: createBar3X(), |
| y: createBar3Y(), |
| opts: []cmp.Option{ |
| IgnoreFields(Bar3{}, |
| "Bar1.Foo3.Bravo", |
| "Bravo.Foo3.Foo2.Foo1.Bravo", |
| "Bravo.Bravo", |
| "Delta.Echo.Charlie", |
| "Foo3.Foo2.Foo1.Alpha", |
| "Alpha", |
| ), |
| }, |
| wantEqual: false, |
| reason: "not equal because one fully-qualified field is not ignored: Bravo.Bar1.Foo3.Foo2.Foo1.Charlie", |
| }, { |
| label: "IgnoreFields", |
| x: createBar3X(), |
| y: createBar3Y(), |
| opts: []cmp.Option{IgnoreFields(Bar3{}, "Bar1", "Bravo", "Delta", "Alpha")}, |
| wantEqual: false, |
| reason: "not equal because highest-level field is not ignored: Foo3", |
| }, { |
| label: "IgnoreFields", |
| x: ParentStruct{ |
| privateStruct: &privateStruct{private: 1}, |
| PublicStruct: &PublicStruct{private: 2}, |
| private: 3, |
| }, |
| y: ParentStruct{ |
| privateStruct: &privateStruct{private: 10}, |
| PublicStruct: &PublicStruct{private: 20}, |
| private: 30, |
| }, |
| opts: []cmp.Option{cmp.AllowUnexported(ParentStruct{}, PublicStruct{}, privateStruct{})}, |
| wantEqual: false, |
| reason: "not equal because unexported fields mismatch", |
| }, { |
| label: "IgnoreFields", |
| x: ParentStruct{ |
| privateStruct: &privateStruct{private: 1}, |
| PublicStruct: &PublicStruct{private: 2}, |
| private: 3, |
| }, |
| y: ParentStruct{ |
| privateStruct: &privateStruct{private: 10}, |
| PublicStruct: &PublicStruct{private: 20}, |
| private: 30, |
| }, |
| opts: []cmp.Option{ |
| cmp.AllowUnexported(ParentStruct{}, PublicStruct{}, privateStruct{}), |
| IgnoreFields(ParentStruct{}, "PublicStruct.private", "privateStruct.private", "private"), |
| }, |
| wantEqual: true, |
| reason: "equal because mismatching unexported fields are ignored", |
| }, { |
| label: "IgnoreTypes", |
| x: []interface{}{5, "same"}, |
| y: []interface{}{6, "same"}, |
| wantEqual: false, |
| reason: "not equal because 5 != 6", |
| }, { |
| label: "IgnoreTypes", |
| x: []interface{}{5, "same"}, |
| y: []interface{}{6, "same"}, |
| opts: []cmp.Option{IgnoreTypes(0)}, |
| wantEqual: true, |
| reason: "equal because ints are ignored", |
| }, { |
| label: "IgnoreTypes+IgnoreInterfaces", |
| x: []interface{}{5, "same", new(bytes.Buffer)}, |
| y: []interface{}{6, "same", new(bytes.Buffer)}, |
| opts: []cmp.Option{IgnoreTypes(0)}, |
| wantPanic: true, |
| reason: "panics because bytes.Buffer has unexported fields", |
| }, { |
| label: "IgnoreTypes+IgnoreInterfaces", |
| x: []interface{}{5, "same", new(bytes.Buffer)}, |
| y: []interface{}{6, "diff", new(bytes.Buffer)}, |
| opts: []cmp.Option{ |
| IgnoreTypes(0, ""), |
| IgnoreInterfaces(struct{ io.Reader }{}), |
| }, |
| wantEqual: true, |
| reason: "equal because bytes.Buffer is ignored by match on interface type", |
| }, { |
| label: "IgnoreTypes+IgnoreInterfaces", |
| x: []interface{}{5, "same", new(bytes.Buffer)}, |
| y: []interface{}{6, "same", new(bytes.Buffer)}, |
| opts: []cmp.Option{ |
| IgnoreTypes(0, ""), |
| IgnoreInterfaces(struct { |
| io.Reader |
| io.Writer |
| fmt.Stringer |
| }{}), |
| }, |
| wantEqual: true, |
| reason: "equal because bytes.Buffer is ignored by match on multiple interface types", |
| }, { |
| label: "IgnoreInterfaces", |
| x: struct{ mu sync.Mutex }{}, |
| y: struct{ mu sync.Mutex }{}, |
| wantPanic: true, |
| reason: "panics because sync.Mutex has unexported fields", |
| }, { |
| label: "IgnoreInterfaces", |
| x: struct{ mu sync.Mutex }{}, |
| y: struct{ mu sync.Mutex }{}, |
| opts: []cmp.Option{IgnoreInterfaces(struct{ sync.Locker }{})}, |
| wantEqual: true, |
| reason: "equal because IgnoreInterfaces applies on values (with pointer receiver)", |
| }, { |
| label: "IgnoreInterfaces", |
| x: struct{ mu *sync.Mutex }{}, |
| y: struct{ mu *sync.Mutex }{}, |
| opts: []cmp.Option{IgnoreInterfaces(struct{ sync.Locker }{})}, |
| wantEqual: true, |
| reason: "equal because IgnoreInterfaces applies on pointers", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2}, |
| y: ParentStruct{Public: 1, private: -2}, |
| opts: []cmp.Option{cmp.AllowUnexported(ParentStruct{})}, |
| wantEqual: false, |
| reason: "not equal because ParentStruct.private differs with AllowUnexported", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2}, |
| y: ParentStruct{Public: 1, private: -2}, |
| opts: []cmp.Option{IgnoreUnexported(ParentStruct{})}, |
| wantEqual: true, |
| reason: "equal because IgnoreUnexported ignored ParentStruct.private", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4}}, |
| y: ParentStruct{Public: 1, private: -2, PublicStruct: &PublicStruct{Public: 3, private: 4}}, |
| opts: []cmp.Option{ |
| cmp.AllowUnexported(PublicStruct{}), |
| IgnoreUnexported(ParentStruct{}), |
| }, |
| wantEqual: true, |
| reason: "equal because ParentStruct.private is ignored", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4}}, |
| y: ParentStruct{Public: 1, private: -2, PublicStruct: &PublicStruct{Public: 3, private: -4}}, |
| opts: []cmp.Option{ |
| cmp.AllowUnexported(PublicStruct{}), |
| IgnoreUnexported(ParentStruct{}), |
| }, |
| wantEqual: false, |
| reason: "not equal because ParentStruct.PublicStruct.private differs and not ignored by IgnoreUnexported(ParentStruct{})", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4}}, |
| y: ParentStruct{Public: 1, private: -2, PublicStruct: &PublicStruct{Public: 3, private: -4}}, |
| opts: []cmp.Option{ |
| IgnoreUnexported(ParentStruct{}, PublicStruct{}), |
| }, |
| wantEqual: true, |
| reason: "equal because both ParentStruct.PublicStruct and ParentStruct.PublicStruct.private are ignored", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}}, |
| y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: -3, private: -4}}, |
| opts: []cmp.Option{ |
| cmp.AllowUnexported(privateStruct{}, PublicStruct{}, ParentStruct{}), |
| }, |
| wantEqual: false, |
| reason: "not equal since ParentStruct.privateStruct differs", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}}, |
| y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: -3, private: -4}}, |
| opts: []cmp.Option{ |
| cmp.AllowUnexported(privateStruct{}, PublicStruct{}), |
| IgnoreUnexported(ParentStruct{}), |
| }, |
| wantEqual: true, |
| reason: "equal because ParentStruct.privateStruct ignored by IgnoreUnexported(ParentStruct{})", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}}, |
| y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: -4}}, |
| opts: []cmp.Option{ |
| cmp.AllowUnexported(PublicStruct{}, ParentStruct{}), |
| IgnoreUnexported(privateStruct{}), |
| }, |
| wantEqual: true, |
| reason: "equal because privateStruct.private ignored by IgnoreUnexported(privateStruct{})", |
| }, { |
| label: "IgnoreUnexported", |
| x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}}, |
| y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: -3, private: -4}}, |
| opts: []cmp.Option{ |
| cmp.AllowUnexported(PublicStruct{}, ParentStruct{}), |
| IgnoreUnexported(privateStruct{}), |
| }, |
| wantEqual: false, |
| reason: "not equal because privateStruct.Public differs and not ignored by IgnoreUnexported(privateStruct{})", |
| }, { |
| label: "IgnoreFields+IgnoreTypes+IgnoreUnexported", |
| x: &Everything{ |
| MyInt: 5, |
| MyFloat: 3.3, |
| MyTime: MyTime{time.Now()}, |
| Bar3: *createBar3X(), |
| ParentStruct: ParentStruct{ |
| Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4}, |
| }, |
| }, |
| y: &Everything{ |
| MyInt: -5, |
| MyFloat: 3.3, |
| MyTime: MyTime{time.Now()}, |
| Bar3: *createBar3Y(), |
| ParentStruct: ParentStruct{ |
| Public: 1, private: -2, PublicStruct: &PublicStruct{Public: -3, private: -4}, |
| }, |
| }, |
| opts: []cmp.Option{ |
| IgnoreFields(Everything{}, "MyTime", "Bar3.Foo3"), |
| IgnoreFields(Bar3{}, "Bar1", "Bravo", "Delta", "Alpha"), |
| IgnoreTypes(MyInt(0), PublicStruct{}), |
| IgnoreUnexported(ParentStruct{}), |
| }, |
| wantEqual: true, |
| reason: "equal because all Ignore options can be composed together", |
| }, { |
| label: "IgnoreSliceElements", |
| x: []int{1, 0, 2, 3, 0, 4, 0, 0}, |
| y: []int{0, 0, 0, 0, 1, 2, 3, 4}, |
| opts: []cmp.Option{ |
| IgnoreSliceElements(func(v int) bool { return v == 0 }), |
| }, |
| wantEqual: true, |
| reason: "equal because zero elements are ignored", |
| }, { |
| label: "IgnoreSliceElements", |
| x: []MyInt{1, 0, 2, 3, 0, 4, 0, 0}, |
| y: []MyInt{0, 0, 0, 0, 1, 2, 3, 4}, |
| opts: []cmp.Option{ |
| IgnoreSliceElements(func(v int) bool { return v == 0 }), |
| }, |
| wantEqual: false, |
| reason: "not equal because MyInt is not assignable to int", |
| }, { |
| label: "IgnoreSliceElements", |
| x: MyInts{1, 0, 2, 3, 0, 4, 0, 0}, |
| y: MyInts{0, 0, 0, 0, 1, 2, 3, 4}, |
| opts: []cmp.Option{ |
| IgnoreSliceElements(func(v int) bool { return v == 0 }), |
| }, |
| wantEqual: true, |
| reason: "equal because the element type of MyInts is assignable to int", |
| }, { |
| label: "IgnoreSliceElements+EquateEmpty", |
| x: []MyInt{}, |
| y: []MyInt{0, 0, 0, 0}, |
| opts: []cmp.Option{ |
| IgnoreSliceElements(func(v int) bool { return v == 0 }), |
| EquateEmpty(), |
| }, |
| wantEqual: false, |
| reason: "not equal because ignored elements does not imply empty slice", |
| }, { |
| label: "IgnoreMapEntries", |
| x: map[string]int{"one": 1, "TWO": 2, "three": 3, "FIVE": 5}, |
| y: map[string]int{"one": 1, "three": 3, "TEN": 10}, |
| opts: []cmp.Option{ |
| IgnoreMapEntries(func(k string, v int) bool { return strings.ToUpper(k) == k }), |
| }, |
| wantEqual: true, |
| reason: "equal because uppercase keys are ignored", |
| }, { |
| label: "IgnoreMapEntries", |
| x: map[MyString]int{"one": 1, "TWO": 2, "three": 3, "FIVE": 5}, |
| y: map[MyString]int{"one": 1, "three": 3, "TEN": 10}, |
| opts: []cmp.Option{ |
| IgnoreMapEntries(func(k string, v int) bool { return strings.ToUpper(k) == k }), |
| }, |
| wantEqual: false, |
| reason: "not equal because MyString is not assignable to string", |
| }, { |
| label: "IgnoreMapEntries", |
| x: map[string]MyInt{"one": 1, "TWO": 2, "three": 3, "FIVE": 5}, |
| y: map[string]MyInt{"one": 1, "three": 3, "TEN": 10}, |
| opts: []cmp.Option{ |
| IgnoreMapEntries(func(k string, v int) bool { return strings.ToUpper(k) == k }), |
| }, |
| wantEqual: false, |
| reason: "not equal because MyInt is not assignable to int", |
| }, { |
| label: "IgnoreMapEntries+EquateEmpty", |
| x: map[string]MyInt{"ONE": 1, "TWO": 2, "THREE": 3}, |
| y: nil, |
| opts: []cmp.Option{ |
| IgnoreMapEntries(func(k string, v int) bool { return strings.ToUpper(k) == k }), |
| EquateEmpty(), |
| }, |
| wantEqual: false, |
| reason: "not equal because ignored entries does not imply empty map", |
| }, { |
| label: "AcyclicTransformer", |
| x: "a\nb\nc\nd", |
| y: "a\nb\nd\nd", |
| opts: []cmp.Option{ |
| AcyclicTransformer("", func(s string) []string { return strings.Split(s, "\n") }), |
| }, |
| wantEqual: false, |
| reason: "not equal because 3rd line differs, but should not recurse infinitely", |
| }, { |
| label: "AcyclicTransformer", |
| x: []string{"foo", "Bar", "BAZ"}, |
| y: []string{"Foo", "BAR", "baz"}, |
| opts: []cmp.Option{ |
| AcyclicTransformer("", strings.ToUpper), |
| }, |
| wantEqual: true, |
| reason: "equal because of strings.ToUpper; AcyclicTransformer unnecessary, but check this still works", |
| }, { |
| label: "AcyclicTransformer", |
| x: "this is a sentence", |
| y: "this is a sentence", |
| opts: []cmp.Option{ |
| AcyclicTransformer("", strings.Fields), |
| }, |
| wantEqual: true, |
| reason: "equal because acyclic transformer splits on any contiguous whitespace", |
| }} |
| |
| for _, tt := range tests { |
| t.Run(tt.label, func(t *testing.T) { |
| var gotEqual bool |
| var gotPanic string |
| func() { |
| defer func() { |
| if ex := recover(); ex != nil { |
| gotPanic = fmt.Sprint(ex) |
| } |
| }() |
| gotEqual = cmp.Equal(tt.x, tt.y, tt.opts...) |
| }() |
| switch { |
| case tt.reason == "": |
| t.Errorf("reason must be provided") |
| case gotPanic == "" && tt.wantPanic: |
| t.Errorf("expected Equal panic\nreason: %s", tt.reason) |
| case gotPanic != "" && !tt.wantPanic: |
| t.Errorf("unexpected Equal panic: got %v\nreason: %v", gotPanic, tt.reason) |
| case gotEqual != tt.wantEqual: |
| t.Errorf("Equal = %v, want %v\nreason: %v", gotEqual, tt.wantEqual, tt.reason) |
| } |
| }) |
| } |
| } |
| |
| func TestPanic(t *testing.T) { |
| args := func(x ...interface{}) []interface{} { return x } |
| tests := []struct { |
| label string // Test name |
| fnc interface{} // Option function to call |
| args []interface{} // Arguments to pass in |
| wantPanic string // Expected panic message |
| reason string // The reason for the expected outcome |
| }{{ |
| label: "EquateApprox", |
| fnc: EquateApprox, |
| args: args(0.0, 0.0), |
| reason: "zero margin and fraction is equivalent to exact equality", |
| }, { |
| label: "EquateApprox", |
| fnc: EquateApprox, |
| args: args(-0.1, 0.0), |
| wantPanic: "margin or fraction must be a non-negative number", |
| reason: "negative inputs are invalid", |
| }, { |
| label: "EquateApprox", |
| fnc: EquateApprox, |
| args: args(0.0, -0.1), |
| wantPanic: "margin or fraction must be a non-negative number", |
| reason: "negative inputs are invalid", |
| }, { |
| label: "EquateApprox", |
| fnc: EquateApprox, |
| args: args(math.NaN(), 0.0), |
| wantPanic: "margin or fraction must be a non-negative number", |
| reason: "NaN inputs are invalid", |
| }, { |
| label: "EquateApprox", |
| fnc: EquateApprox, |
| args: args(1.0, 0.0), |
| reason: "fraction of 1.0 or greater is valid", |
| }, { |
| label: "EquateApprox", |
| fnc: EquateApprox, |
| args: args(0.0, math.Inf(+1)), |
| reason: "margin of infinity is valid", |
| }, { |
| label: "EquateApproxTime", |
| fnc: EquateApproxTime, |
| args: args(time.Duration(-1)), |
| wantPanic: "margin must be a non-negative number", |
| reason: "negative duration is invalid", |
| }, { |
| label: "SortSlices", |
| fnc: SortSlices, |
| args: args(strings.Compare), |
| wantPanic: "invalid less function", |
| reason: "func(x, y string) int is wrong signature for less", |
| }, { |
| label: "SortSlices", |
| fnc: SortSlices, |
| args: args((func(_, _ int) bool)(nil)), |
| wantPanic: "invalid less function", |
| reason: "nil value is not valid", |
| }, { |
| label: "SortMaps", |
| fnc: SortMaps, |
| args: args(strings.Compare), |
| wantPanic: "invalid less function", |
| reason: "func(x, y string) int is wrong signature for less", |
| }, { |
| label: "SortMaps", |
| fnc: SortMaps, |
| args: args((func(_, _ int) bool)(nil)), |
| wantPanic: "invalid less function", |
| reason: "nil value is not valid", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(Foo1{}, ""), |
| wantPanic: "name must not be empty", |
| reason: "empty selector is invalid", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(Foo1{}, "."), |
| wantPanic: "name must not be empty", |
| reason: "single dot selector is invalid", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(Foo1{}, ".Alpha"), |
| reason: "dot-prefix is okay since Foo1.Alpha reads naturally", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(Foo1{}, "Alpha."), |
| wantPanic: "name must not be empty", |
| reason: "dot-suffix is invalid", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(Foo1{}, "Alpha "), |
| wantPanic: "does not exist", |
| reason: "identifiers must not have spaces", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(Foo1{}, "Zulu"), |
| wantPanic: "does not exist", |
| reason: "name of non-existent field is invalid", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(Foo1{}, "Alpha.NoExist"), |
| wantPanic: "must be a struct", |
| reason: "cannot select into a non-struct", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(&Foo1{}, "Alpha"), |
| wantPanic: "must be a non-pointer struct", |
| reason: "the type must be a struct (not pointer to a struct)", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(struct{ privateStruct }{}, "privateStruct"), |
| reason: "privateStruct field permitted since it is the default name of the embedded type", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(struct{ privateStruct }{}, "Public"), |
| reason: "Public field permitted since it is a forwarded field that is exported", |
| }, { |
| label: "IgnoreFields", |
| fnc: IgnoreFields, |
| args: args(struct{ privateStruct }{}, "private"), |
| wantPanic: "does not exist", |
| reason: "private field not permitted since it is a forwarded field that is unexported", |
| }, { |
| label: "IgnoreTypes", |
| fnc: IgnoreTypes, |
| reason: "empty input is valid", |
| }, { |
| label: "IgnoreTypes", |
| fnc: IgnoreTypes, |
| args: args(nil), |
| wantPanic: "cannot determine type", |
| reason: "input must not be nil value", |
| }, { |
| label: "IgnoreTypes", |
| fnc: IgnoreTypes, |
| args: args(0, 0, 0), |
| reason: "duplicate inputs of the same type is valid", |
| }, { |
| label: "IgnoreInterfaces", |
| fnc: IgnoreInterfaces, |
| args: args(nil), |
| wantPanic: "input must be an anonymous struct", |
| reason: "input must not be nil value", |
| }, { |
| label: "IgnoreInterfaces", |
| fnc: IgnoreInterfaces, |
| args: args(Foo1{}), |
| wantPanic: "input must be an anonymous struct", |
| reason: "input must not be a named struct type", |
| }, { |
| label: "IgnoreInterfaces", |
| fnc: IgnoreInterfaces, |
| args: args(struct{ _ io.Reader }{}), |
| wantPanic: "struct cannot have named fields", |
| reason: "input must not have named fields", |
| }, { |
| label: "IgnoreInterfaces", |
| fnc: IgnoreInterfaces, |
| args: args(struct{ Foo1 }{}), |
| wantPanic: "embedded field must be an interface type", |
| reason: "field types must be interfaces", |
| }, { |
| label: "IgnoreInterfaces", |
| fnc: IgnoreInterfaces, |
| args: args(struct{ EmptyInterface }{}), |
| wantPanic: "cannot ignore empty interface", |
| reason: "field types must not be the empty interface", |
| }, { |
| label: "IgnoreInterfaces", |
| fnc: IgnoreInterfaces, |
| args: args(struct { |
| io.Reader |
| io.Writer |
| io.Closer |
| io.ReadWriteCloser |
| }{}), |
| reason: "multiple interfaces may be specified, even if they overlap", |
| }, { |
| label: "IgnoreUnexported", |
| fnc: IgnoreUnexported, |
| reason: "empty input is valid", |
| }, { |
| label: "IgnoreUnexported", |
| fnc: IgnoreUnexported, |
| args: args(nil), |
| wantPanic: "must be a non-pointer struct", |
| reason: "input must not be nil value", |
| }, { |
| label: "IgnoreUnexported", |
| fnc: IgnoreUnexported, |
| args: args(&Foo1{}), |
| wantPanic: "must be a non-pointer struct", |
| reason: "input must be a struct type (not a pointer to a struct)", |
| }, { |
| label: "IgnoreUnexported", |
| fnc: IgnoreUnexported, |
| args: args(Foo1{}, struct{ x, X int }{}), |
| reason: "input may be named or unnamed structs", |
| }, { |
| label: "AcyclicTransformer", |
| fnc: AcyclicTransformer, |
| args: args("", "not a func"), |
| wantPanic: "invalid transformer function", |
| reason: "AcyclicTransformer has same input requirements as Transformer", |
| }} |
| |
| for _, tt := range tests { |
| t.Run(tt.label, func(t *testing.T) { |
| // Prepare function arguments. |
| vf := reflect.ValueOf(tt.fnc) |
| var vargs []reflect.Value |
| for i, arg := range tt.args { |
| if arg == nil { |
| tf := vf.Type() |
| if i == tf.NumIn()-1 && tf.IsVariadic() { |
| vargs = append(vargs, reflect.Zero(tf.In(i).Elem())) |
| } else { |
| vargs = append(vargs, reflect.Zero(tf.In(i))) |
| } |
| } else { |
| vargs = append(vargs, reflect.ValueOf(arg)) |
| } |
| } |
| |
| // Call the function and capture any panics. |
| var gotPanic string |
| func() { |
| defer func() { |
| if ex := recover(); ex != nil { |
| if s, ok := ex.(string); ok { |
| gotPanic = s |
| } else { |
| panic(ex) |
| } |
| } |
| }() |
| vf.Call(vargs) |
| }() |
| |
| switch { |
| case tt.reason == "": |
| t.Errorf("reason must be provided") |
| case tt.wantPanic == "" && gotPanic != "": |
| t.Errorf("unexpected panic message: %s\nreason: %s", gotPanic, tt.reason) |
| case tt.wantPanic != "" && !strings.Contains(gotPanic, tt.wantPanic): |
| t.Errorf("panic message:\ngot: %s\nwant: %s\nreason: %s", gotPanic, tt.wantPanic, tt.reason) |
| } |
| }) |
| } |
| } |
