| // Copyright 2021 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 maps |
| |
| import ( |
| "math" |
| "sort" |
| "strconv" |
| "testing" |
| |
| "golang.org/x/exp/slices" |
| ) |
| |
| var m1 = map[int]int{1: 2, 2: 4, 4: 8, 8: 16} |
| var m2 = map[int]string{1: "2", 2: "4", 4: "8", 8: "16"} |
| |
| func TestKeys(t *testing.T) { |
| want := []int{1, 2, 4, 8} |
| |
| got1 := Keys(m1) |
| sort.Ints(got1) |
| if !slices.Equal(got1, want) { |
| t.Errorf("Keys(%v) = %v, want %v", m1, got1, want) |
| } |
| |
| got2 := Keys(m2) |
| sort.Ints(got2) |
| if !slices.Equal(got2, want) { |
| t.Errorf("Keys(%v) = %v, want %v", m2, got2, want) |
| } |
| } |
| |
| func TestValues(t *testing.T) { |
| got1 := Values(m1) |
| want1 := []int{2, 4, 8, 16} |
| sort.Ints(got1) |
| if !slices.Equal(got1, want1) { |
| t.Errorf("Values(%v) = %v, want %v", m1, got1, want1) |
| } |
| |
| got2 := Values(m2) |
| want2 := []string{"16", "2", "4", "8"} |
| sort.Strings(got2) |
| if !slices.Equal(got2, want2) { |
| t.Errorf("Values(%v) = %v, want %v", m2, got2, want2) |
| } |
| } |
| |
| func TestEqual(t *testing.T) { |
| if !Equal(m1, m1) { |
| t.Errorf("Equal(%v, %v) = false, want true", m1, m1) |
| } |
| if Equal(m1, (map[int]int)(nil)) { |
| t.Errorf("Equal(%v, nil) = true, want false", m1) |
| } |
| if Equal((map[int]int)(nil), m1) { |
| t.Errorf("Equal(nil, %v) = true, want false", m1) |
| } |
| if !Equal[map[int]int, map[int]int](nil, nil) { |
| t.Error("Equal(nil, nil) = false, want true") |
| } |
| if ms := map[int]int{1: 2}; Equal(m1, ms) { |
| t.Errorf("Equal(%v, %v) = true, want false", m1, ms) |
| } |
| |
| // Comparing NaN for equality is expected to fail. |
| mf := map[int]float64{1: 0, 2: math.NaN()} |
| if Equal(mf, mf) { |
| t.Errorf("Equal(%v, %v) = true, want false", mf, mf) |
| } |
| } |
| |
| // equal is simply ==. |
| func equal[T comparable](v1, v2 T) bool { |
| return v1 == v2 |
| } |
| |
| // equalNaN is like == except that all NaNs are equal. |
| func equalNaN[T comparable](v1, v2 T) bool { |
| isNaN := func(f T) bool { return f != f } |
| return v1 == v2 || (isNaN(v1) && isNaN(v2)) |
| } |
| |
| // equalStr compares ints and strings. |
| func equalIntStr(v1 int, v2 string) bool { |
| return strconv.Itoa(v1) == v2 |
| } |
| |
| func TestEqualFunc(t *testing.T) { |
| if !EqualFunc(m1, m1, equal[int]) { |
| t.Errorf("EqualFunc(%v, %v, equal) = false, want true", m1, m1) |
| } |
| if EqualFunc(m1, (map[int]int)(nil), equal[int]) { |
| t.Errorf("EqualFunc(%v, nil, equal) = true, want false", m1) |
| } |
| if EqualFunc((map[int]int)(nil), m1, equal[int]) { |
| t.Errorf("EqualFunc(nil, %v, equal) = true, want false", m1) |
| } |
| if !EqualFunc[map[int]int, map[int]int](nil, nil, equal[int]) { |
| t.Error("EqualFunc(nil, nil, equal) = false, want true") |
| } |
| if ms := map[int]int{1: 2}; EqualFunc(m1, ms, equal[int]) { |
| t.Errorf("EqualFunc(%v, %v, equal) = true, want false", m1, ms) |
| } |
| |
| // Comparing NaN for equality is expected to fail. |
| mf := map[int]float64{1: 0, 2: math.NaN()} |
| if EqualFunc(mf, mf, equal[float64]) { |
| t.Errorf("EqualFunc(%v, %v, equal) = true, want false", mf, mf) |
| } |
| // But it should succeed using equalNaN. |
| if !EqualFunc(mf, mf, equalNaN[float64]) { |
| t.Errorf("EqualFunc(%v, %v, equalNaN) = false, want true", mf, mf) |
| } |
| |
| if !EqualFunc(m1, m2, equalIntStr) { |
| t.Errorf("EqualFunc(%v, %v, equalIntStr) = false, want true", m1, m2) |
| } |
| } |
| |
| func TestClear(t *testing.T) { |
| ml := map[int]int{1: 1, 2: 2, 3: 3} |
| Clear(ml) |
| if got := len(ml); got != 0 { |
| t.Errorf("len(%v) = %d after Clear, want 0", ml, got) |
| } |
| if !Equal(ml, (map[int]int)(nil)) { |
| t.Errorf("Equal(%v, nil) = false, want true", ml) |
| } |
| } |
| |
| func TestClone(t *testing.T) { |
| mc := Clone(m1) |
| if !Equal(mc, m1) { |
| t.Errorf("Clone(%v) = %v, want %v", m1, mc, m1) |
| } |
| mc[16] = 32 |
| if Equal(mc, m1) { |
| t.Errorf("Equal(%v, %v) = true, want false", mc, m1) |
| } |
| } |
| |
| func TestCopy(t *testing.T) { |
| mc := Clone(m1) |
| Copy(mc, mc) |
| if !Equal(mc, m1) { |
| t.Errorf("Copy(%v, %v) = %v, want %v", m1, m1, mc, m1) |
| } |
| Copy(mc, map[int]int{16: 32}) |
| want := map[int]int{1: 2, 2: 4, 4: 8, 8: 16, 16: 32} |
| if !Equal(mc, want) { |
| t.Errorf("Copy result = %v, want %v", mc, want) |
| } |
| } |
| |
| func TestDeleteFunc(t *testing.T) { |
| mc := Clone(m1) |
| DeleteFunc(mc, func(int, int) bool { return false }) |
| if !Equal(mc, m1) { |
| t.Errorf("DeleteFunc(%v, true) = %v, want %v", m1, mc, m1) |
| } |
| DeleteFunc(mc, func(k, v int) bool { return k > 3 }) |
| want := map[int]int{1: 2, 2: 4} |
| if !Equal(mc, want) { |
| t.Errorf("DeleteFunc result = %v, want %v", mc, want) |
| } |
| } |