gf/util/gutil/gutil_z_unit_map_test.go
2021-11-13 23:30:31 +08:00

173 lines
3.8 KiB
Go
Executable File

// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gutil_test
import (
"testing"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/test/gtest"
"github.com/gogf/gf/v2/util/gutil"
)
func Test_MapCopy(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m1 := g.Map{
"k1": "v1",
}
m2 := gutil.MapCopy(m1)
m2["k2"] = "v2"
t.Assert(m1["k1"], "v1")
t.Assert(m1["k2"], nil)
t.Assert(m2["k1"], "v1")
t.Assert(m2["k2"], "v2")
})
}
func Test_MapContains(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m1 := g.Map{
"k1": "v1",
}
t.Assert(gutil.MapContains(m1, "k1"), true)
t.Assert(gutil.MapContains(m1, "K1"), false)
t.Assert(gutil.MapContains(m1, "k2"), false)
})
}
func Test_MapMerge(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m1 := g.Map{
"k1": "v1",
}
m2 := g.Map{
"k2": "v2",
}
m3 := g.Map{
"k3": "v3",
}
gutil.MapMerge(m1, m2, m3, nil)
t.Assert(m1["k1"], "v1")
t.Assert(m1["k2"], "v2")
t.Assert(m1["k3"], "v3")
t.Assert(m2["k1"], nil)
t.Assert(m3["k1"], nil)
})
}
func Test_MapMergeCopy(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m1 := g.Map{
"k1": "v1",
}
m2 := g.Map{
"k2": "v2",
}
m3 := g.Map{
"k3": "v3",
}
m := gutil.MapMergeCopy(m1, m2, m3, nil)
t.Assert(m["k1"], "v1")
t.Assert(m["k2"], "v2")
t.Assert(m["k3"], "v3")
t.Assert(m1["k1"], "v1")
t.Assert(m1["k2"], nil)
t.Assert(m2["k1"], nil)
t.Assert(m3["k1"], nil)
})
}
func Test_MapPossibleItemByKey(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m := g.Map{
"name": "guo",
"NickName": "john",
}
k, v := gutil.MapPossibleItemByKey(m, "NAME")
t.Assert(k, "name")
t.Assert(v, "guo")
k, v = gutil.MapPossibleItemByKey(m, "nick name")
t.Assert(k, "NickName")
t.Assert(v, "john")
k, v = gutil.MapPossibleItemByKey(m, "none")
t.Assert(k, "")
t.Assert(v, nil)
})
}
func Test_MapContainsPossibleKey(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m := g.Map{
"name": "guo",
"NickName": "john",
}
t.Assert(gutil.MapContainsPossibleKey(m, "name"), true)
t.Assert(gutil.MapContainsPossibleKey(m, "NAME"), true)
t.Assert(gutil.MapContainsPossibleKey(m, "nickname"), true)
t.Assert(gutil.MapContainsPossibleKey(m, "nick name"), true)
t.Assert(gutil.MapContainsPossibleKey(m, "nick_name"), true)
t.Assert(gutil.MapContainsPossibleKey(m, "nick-name"), true)
t.Assert(gutil.MapContainsPossibleKey(m, "nick.name"), true)
t.Assert(gutil.MapContainsPossibleKey(m, "none"), false)
})
}
func Test_MapOmitEmpty(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m := g.Map{
"k1": "john",
"e1": "",
"e2": 0,
"e3": nil,
"k2": "smith",
}
gutil.MapOmitEmpty(m)
t.Assert(len(m), 2)
t.AssertNE(m["k1"], nil)
t.AssertNE(m["k2"], nil)
})
}
func Test_MapToSlice(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m := g.Map{
"k1": "v1",
"k2": "v2",
}
s := gutil.MapToSlice(m)
t.Assert(len(s), 4)
t.AssertIN(s[0], g.Slice{"k1", "k2", "v1", "v2"})
t.AssertIN(s[1], g.Slice{"k1", "k2", "v1", "v2"})
t.AssertIN(s[2], g.Slice{"k1", "k2", "v1", "v2"})
t.AssertIN(s[3], g.Slice{"k1", "k2", "v1", "v2"})
})
gtest.C(t, func(t *gtest.T) {
m := g.MapStrStr{
"k1": "v1",
"k2": "v2",
}
s := gutil.MapToSlice(m)
t.Assert(len(s), 4)
t.AssertIN(s[0], g.Slice{"k1", "k2", "v1", "v2"})
t.AssertIN(s[1], g.Slice{"k1", "k2", "v1", "v2"})
t.AssertIN(s[2], g.Slice{"k1", "k2", "v1", "v2"})
t.AssertIN(s[3], g.Slice{"k1", "k2", "v1", "v2"})
})
gtest.C(t, func(t *gtest.T) {
m := g.MapStrStr{}
s := gutil.MapToSlice(m)
t.Assert(len(s), 0)
})
gtest.C(t, func(t *gtest.T) {
s := gutil.MapToSlice(1)
t.Assert(s, nil)
})
}