diff --git a/g/database/gredis/gredis_unit_test.go b/g/database/gredis/gredis_unit_test.go index ca37f1293..e0dcf7e94 100644 --- a/g/database/gredis/gredis_unit_test.go +++ b/g/database/gredis/gredis_unit_test.go @@ -7,133 +7,203 @@ package gredis_test import ( - "github.com/gogf/gf/g/database/gredis" - "github.com/gogf/gf/g/test/gtest" - "testing" - "time" + "github.com/gogf/gf/g/database/gredis" + "github.com/gogf/gf/g/test/gtest" + redis2 "github.com/gogf/gf/third/github.com/gomodule/redigo/redis" + "testing" + "time" ) var ( - config = gredis.Config{ - Host : "127.0.0.1", - Port : 6379, - Db : 1, - } + config = gredis.Config{ + Host: "127.0.0.1", + Port: 6379, + Db: 1, + } ) func Test_NewClose(t *testing.T) { - gtest.Case(t, func() { - redis := gredis.New(config) - gtest.AssertNE(redis, nil) - err := redis.Close() - gtest.Assert(err, nil) - }) + gtest.Case(t, func() { + redis := gredis.New(config) + gtest.AssertNE(redis, nil) + err := redis.Close() + gtest.Assert(err, nil) + }) } func Test_Do(t *testing.T) { - gtest.Case(t, func() { - redis := gredis.New(config) - defer redis.Close() - _, err := redis.Do("SET", "k", "v") - gtest.Assert(err, nil) + gtest.Case(t, func() { + redis := gredis.New(config) + defer redis.Close() + _, err := redis.Do("SET", "k", "v") + gtest.Assert(err, nil) - r, err := redis.Do("GET", "k") - gtest.Assert(err, nil) - gtest.Assert(r, []byte("v")) + r, err := redis.Do("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(r, []byte("v")) - _, err = redis.Do("DEL", "k") - gtest.Assert(err, nil) - r, err = redis.Do("GET", "k") - gtest.Assert(err, nil) - gtest.Assert(r, nil) - }) + _, err = redis.Do("DEL", "k") + gtest.Assert(err, nil) + r, err = redis.Do("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(r, nil) + }) } func Test_Send(t *testing.T) { - gtest.Case(t, func() { - redis := gredis.New(config) - defer redis.Close() - err := redis.Send("SET", "k", "v") - gtest.Assert(err, nil) + gtest.Case(t, func() { + redis := gredis.New(config) + defer redis.Close() + err := redis.Send("SET", "k", "v") + gtest.Assert(err, nil) - r, err := redis.Do("GET", "k") - gtest.Assert(err, nil) - gtest.Assert(r, []byte("v")) - }) + r, err := redis.Do("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(r, []byte("v")) + }) } func Test_Stats(t *testing.T) { - gtest.Case(t, func() { - redis := gredis.New(config) - defer redis.Close() - redis.SetMaxIdle(2) - redis.SetMaxActive(100) - redis.SetIdleTimeout(500*time.Millisecond) - redis.SetMaxConnLifetime(500*time.Millisecond) + gtest.Case(t, func() { + redis := gredis.New(config) + defer redis.Close() + redis.SetMaxIdle(2) + redis.SetMaxActive(100) + redis.SetIdleTimeout(500 * time.Millisecond) + redis.SetMaxConnLifetime(500 * time.Millisecond) - array := make([]*gredis.Conn, 0) - for i := 0; i < 10; i++ { - array = append(array, redis.Conn()) - } - stats := redis.Stats() - gtest.Assert(stats.ActiveCount, 10) - gtest.Assert(stats.IdleCount, 0) - for i := 0; i < 10; i++ { - array[i].Close() - } - stats = redis.Stats() - gtest.Assert(stats.ActiveCount, 2) - gtest.Assert(stats.IdleCount, 2) - //time.Sleep(3000*time.Millisecond) - //stats = redis.Stats() - //fmt.Println(stats) - //gtest.Assert(stats.ActiveCount, 0) - //gtest.Assert(stats.IdleCount, 0) - }) + array := make([]*gredis.Conn, 0) + for i := 0; i < 10; i++ { + array = append(array, redis.Conn()) + } + stats := redis.Stats() + gtest.Assert(stats.ActiveCount, 10) + gtest.Assert(stats.IdleCount, 0) + for i := 0; i < 10; i++ { + array[i].Close() + } + stats = redis.Stats() + gtest.Assert(stats.ActiveCount, 2) + gtest.Assert(stats.IdleCount, 2) + //time.Sleep(3000*time.Millisecond) + //stats = redis.Stats() + //fmt.Println(stats) + //gtest.Assert(stats.ActiveCount, 0) + //gtest.Assert(stats.IdleCount, 0) + }) } func Test_Conn(t *testing.T) { - gtest.Case(t, func() { - redis := gredis.New(config) - defer redis.Close() - conn := redis.Conn() - defer conn.Close() + gtest.Case(t, func() { + redis := gredis.New(config) + defer redis.Close() + conn := redis.Conn() + defer conn.Close() + r, err := conn.Do("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(r, []byte("v")) - r, err := conn.Do("GET", "k") - gtest.Assert(err, nil) - gtest.Assert(r, []byte("v")) - - _, err = conn.Do("DEL", "k") - gtest.Assert(err, nil) - r, err = conn.Do("GET", "k") - gtest.Assert(err, nil) - gtest.Assert(r, nil) - }) + _, err = conn.Do("DEL", "k") + gtest.Assert(err, nil) + r, err = conn.Do("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(r, nil) + }) } func Test_Instance(t *testing.T) { - gtest.Case(t, func() { - group := "my-test" - gredis.SetConfig(config, group) - defer gredis.RemoveConfig(group) - redis := gredis.Instance(group) - defer redis.Close() + gtest.Case(t, func() { + group := "my-test" + gredis.SetConfig(config, group) + defer gredis.RemoveConfig(group) + redis := gredis.Instance(group) + defer redis.Close() - conn := redis.Conn() - defer conn.Close() + conn := redis.Conn() + defer conn.Close() - _, err := conn.Do("SET", "k", "v") - gtest.Assert(err, nil) + _, err := conn.Do("SET", "k", "v") + gtest.Assert(err, nil) - r, err := conn.Do("GET", "k") - gtest.Assert(err, nil) - gtest.Assert(r, []byte("v")) + r, err := conn.Do("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(r, []byte("v")) - _, err = conn.Do("DEL", "k") - gtest.Assert(err, nil) - r, err = conn.Do("GET", "k") - gtest.Assert(err, nil) - gtest.Assert(r, nil) - }) + _, err = conn.Do("DEL", "k") + gtest.Assert(err, nil) + r, err = conn.Do("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(r, nil) + }) +} + +func Test_Basic(t *testing.T) { + gtest.Case(t, func() { + config1 := gredis.Config{ + Host: "127.0.0.2", + Port: 6379, + Db: 1, + } + redis := gredis.New(config1) + _, err := redis.Do("info") + gtest.Assert(err == nil, false) + + config1 = gredis.Config{ + Host: "127.0.0.1", + Port: 6379, + Db: 1, + Pass: "666666", + } + redis = gredis.New(config1) + _, err = redis.Do("info") + gtest.Assert(err == nil, false) + + config1 = gredis.Config{ + Host: "127.0.0.1", + Port: 6379, + Db: 100, + } + redis = gredis.New(config1) + _, err = redis.Do("info") + gtest.Assert(err == nil, false) + + redis = gredis.Instance("gf") + gtest.Assert(redis == nil, true) + gredis.ClearConfig() + + redis = gredis.New(config) + defer redis.Close() + _, err = redis.DoVar("SET", "k", "v") + gtest.Assert(err, nil) + + v, err := redis.DoVar("GET", "k") + gtest.Assert(err, nil) + gtest.Assert(v.String(), "v") + + conn := redis.GetConn() + _, err = conn.DoVar("SET", "k", "v") + gtest.Assert(err, nil) + + //v, err = conn.ReceiveVar() + //gtest.Assert(err, nil) + //gtest.Assert(v.String(), "v") + + psc := redis2.PubSubConn{Conn: conn} + psc.Subscribe("gf") + redis.DoVar("PUBLISH", "gf", "gf test") + go func() { + for { + v, _ := conn.ReceiveVar() + switch obj := v.Val().(type) { + case redis2.Message: + gtest.Assert(string(obj.Data), "gf test") + case redis2.Subscription: + + } + } + }() + + time.Sleep(time.Second) + }) } diff --git a/g/encoding/gcompress/gcompress_test.go b/g/encoding/gcompress/gcompress_test.go index df1bbb6f3..dcd8f5c06 100644 --- a/g/encoding/gcompress/gcompress_test.go +++ b/g/encoding/gcompress/gcompress_test.go @@ -18,6 +18,11 @@ func TestZlib(t *testing.T) { gtest.Assert(gcompress.Zlib([]byte(src)), dst) gtest.Assert(gcompress.UnZlib(dst), []byte(src)) + + gtest.Assert(gcompress.Zlib(nil), nil) + gtest.Assert(gcompress.UnZlib(nil), nil) + + gtest.Assert(gcompress.UnZlib(dst[1:]), nil) }) } @@ -36,7 +41,10 @@ func TestGzip(t *testing.T) { 0x00, 0x00, } - gtest.Assert(gcompress.Gzip([]byte(src)), gzip) + arr := []byte(src) + gtest.Assert(gcompress.Gzip(arr), gzip) - gtest.Assert(gcompress.UnGzip(gzip), []byte(src)) + gtest.Assert(gcompress.UnGzip(gzip), arr) + + gtest.Assert(gcompress.UnGzip(gzip[1:]), nil) } diff --git a/g/encoding/gjson/gjson_z_unit_basic_test.go b/g/encoding/gjson/gjson_z_unit_basic_test.go index 0a43eee58..20bc1b5fd 100644 --- a/g/encoding/gjson/gjson_z_unit_basic_test.go +++ b/g/encoding/gjson/gjson_z_unit_basic_test.go @@ -7,221 +7,221 @@ package gjson_test import ( - "github.com/gogf/gf/g" - "github.com/gogf/gf/g/encoding/gjson" - "github.com/gogf/gf/g/test/gtest" - "testing" + "github.com/gogf/gf/g" + "github.com/gogf/gf/g/encoding/gjson" + "github.com/gogf/gf/g/test/gtest" + "testing" ) func Test_New(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gjson.New(data) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gjson.New(data) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + }) } func Test_NewUnsafe(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gjson.NewUnsafe(data) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gjson.NewUnsafe(data) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Valid(t *testing.T) { - data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`) - gtest.Case(t, func() { - gtest.Assert(gjson.Valid(data1), true) - gtest.Assert(gjson.Valid(data2), false) - }) + data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`) + gtest.Case(t, func() { + gtest.Assert(gjson.Valid(data1), true) + gtest.Assert(gjson.Valid(data2), false) + }) } func Test_Encode(t *testing.T) { - value := g.Slice{1, 2, 3} - gtest.Case(t, func() { - b, err := gjson.Encode(value) - gtest.Assert(err, nil) - gtest.Assert(b, []byte(`[1,2,3]`)) - }) + value := g.Slice{1, 2, 3} + gtest.Case(t, func() { + b, err := gjson.Encode(value) + gtest.Assert(err, nil) + gtest.Assert(b, []byte(`[1,2,3]`)) + }) } func Test_Decode(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - v, err := gjson.Decode(data) - gtest.Assert(err, nil) - gtest.Assert(v, g.Map{ - "n" : 123456789, - "a" : g.Slice{1, 2, 3}, - "m" : g.Map{ - "k" : "v", - }, - }) - }) - gtest.Case(t, func() { - var v interface{} - err := gjson.DecodeTo(data, &v) - gtest.Assert(err, nil) - gtest.Assert(v, g.Map{ - "n" : 123456789, - "a" : g.Slice{1, 2, 3}, - "m" : g.Map{ - "k" : "v", - }, - }) - }) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + v, err := gjson.Decode(data) + gtest.Assert(err, nil) + gtest.Assert(v, g.Map{ + "n": 123456789, + "a": g.Slice{1, 2, 3}, + "m": g.Map{ + "k": "v", + }, + }) + }) + gtest.Case(t, func() { + var v interface{} + err := gjson.DecodeTo(data, &v) + gtest.Assert(err, nil) + gtest.Assert(v, g.Map{ + "n": 123456789, + "a": g.Slice{1, 2, 3}, + "m": g.Map{ + "k": "v", + }, + }) + }) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_SplitChar(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - j.SetSplitChar(byte('#')) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m#k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a#1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + j.SetSplitChar(byte('#')) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m#k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a#1"), 2) + }) } func Test_ViolenceCheck(t *testing.T) { - data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("m.a.2"), 3) - gtest.Assert(j.Get("m.v1.v2"), nil) - j.SetViolenceCheck(true) - gtest.Assert(j.Get("m.v1.v2"), 4) - }) + data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("m.a.2"), 3) + gtest.Assert(j.Get("m.v1.v2"), nil) + j.SetViolenceCheck(true) + gtest.Assert(j.Get("m.v1.v2"), 4) + }) } func Test_GetToVar(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - var m map[string]string - var n int - var a []int - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + var m map[string]string + var n int + var a []int + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) - j.GetToVar("n", &n) - j.GetToVar("m", &m) - j.GetToVar("a", &a) + j.GetToVar("n", &n) + j.GetToVar("m", &m) + j.GetToVar("a", &a) - gtest.Assert(n, "123456789") - gtest.Assert(m, g.Map{"k" : "v"}) - gtest.Assert(a, g.Slice{1, 2, 3}) - }) + gtest.Assert(n, "123456789") + gtest.Assert(m, g.Map{"k": "v"}) + gtest.Assert(a, g.Slice{1, 2, 3}) + }) } func Test_GetMap(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - gtest.Assert(j.GetMap("n"), nil) - gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"}) - gtest.Assert(j.GetMap("a"), nil) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + gtest.Assert(j.GetMap("n"), nil) + gtest.Assert(j.GetMap("m"), g.Map{"k": "v"}) + gtest.Assert(j.GetMap("a"), nil) + }) } func Test_GetJson(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - j2 := j.GetJson("m") - gtest.AssertNE(j2, nil) - gtest.Assert(j2.Get("k"), "v") - gtest.Assert(j2.Get("a"), nil) - gtest.Assert(j2.Get("n"), nil) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + j2 := j.GetJson("m") + gtest.AssertNE(j2, nil) + gtest.Assert(j2.Get("k"), "v") + gtest.Assert(j2.Get("a"), nil) + gtest.Assert(j2.Get("n"), nil) + }) } func Test_GetArray(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - gtest.Assert(j.GetArray("n"), g.Array{123456789}) - gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k":"v"}}) - gtest.Assert(j.GetArray("a"), g.Array{1,2,3}) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + gtest.Assert(j.GetArray("n"), g.Array{123456789}) + gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k": "v"}}) + gtest.Assert(j.GetArray("a"), g.Array{1, 2, 3}) + }) } func Test_GetString(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - gtest.AssertEQ(j.GetString("n"), "123456789") - gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`) - gtest.AssertEQ(j.GetString("a"), `[1,2,3]`) - gtest.AssertEQ(j.GetString("i"), "") - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + gtest.AssertEQ(j.GetString("n"), "123456789") + gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`) + gtest.AssertEQ(j.GetString("a"), `[1,2,3]`) + gtest.AssertEQ(j.GetString("i"), "") + }) } func Test_GetStrings(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"}) - gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`}) - gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"}) - gtest.AssertEQ(j.GetStrings("i"), nil) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"}) + gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`}) + gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"}) + gtest.AssertEQ(j.GetStrings("i"), nil) + }) } func Test_GetInterfaces(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j, err := gjson.DecodeToJson(data) - gtest.Assert(err, nil) - gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789}) - gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k":"v"}}) - gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1,2,3}) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j, err := gjson.DecodeToJson(data) + gtest.Assert(err, nil) + gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789}) + gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k": "v"}}) + gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1, 2, 3}) + }) } func Test_Len(t *testing.T) { - gtest.Case(t, func() { - p := gjson.New(nil) - p.Append("a", 1) - p.Append("a", 2) - gtest.Assert(p.Len("a"), 2) - }) - gtest.Case(t, func() { - p := gjson.New(nil) - p.Append("a.b", 1) - p.Append("a.c", 2) - gtest.Assert(p.Len("a"), 2) - }) - gtest.Case(t, func() { - p := gjson.New(nil) - p.Set("a", 1) - gtest.Assert(p.Len("a"), -1) - }) + gtest.Case(t, func() { + p := gjson.New(nil) + p.Append("a", 1) + p.Append("a", 2) + gtest.Assert(p.Len("a"), 2) + }) + gtest.Case(t, func() { + p := gjson.New(nil) + p.Append("a.b", 1) + p.Append("a.c", 2) + gtest.Assert(p.Len("a"), 2) + }) + gtest.Case(t, func() { + p := gjson.New(nil) + p.Set("a", 1) + gtest.Assert(p.Len("a"), -1) + }) } func Test_Append(t *testing.T) { @@ -236,8 +236,8 @@ func Test_Append(t *testing.T) { p.Append("a.b", 1) p.Append("a.c", 2) gtest.Assert(p.Get("a"), g.Map{ - "b" : g.Slice{1}, - "c" : g.Slice{2}, + "b": g.Slice{1}, + "c": g.Slice{2}, }) }) gtest.Case(t, func() { @@ -282,21 +282,181 @@ func TestJson_Default(t *testing.T) { gtest.AssertEQ(j.GetUint64("no", 100), uint64(100)) gtest.AssertEQ(j.GetFloat32("no", 123.456), float32(123.456)) gtest.AssertEQ(j.GetFloat64("no", 123.456), float64(123.456)) - gtest.AssertEQ(j.GetArray("no", g.Slice{1,2,3}), g.Slice{1,2,3}) - gtest.AssertEQ(j.GetInts("no", g.Slice{1,2,3}), g.SliceInt{1,2,3}) - gtest.AssertEQ(j.GetFloats("no", g.Slice{1,2,3}), []float64{1,2,3}) - gtest.AssertEQ(j.GetMap("no", g.Map{"k":"v"}), g.Map{"k":"v"}) + gtest.AssertEQ(j.GetArray("no", g.Slice{1, 2, 3}), g.Slice{1, 2, 3}) + gtest.AssertEQ(j.GetInts("no", g.Slice{1, 2, 3}), g.SliceInt{1, 2, 3}) + gtest.AssertEQ(j.GetFloats("no", g.Slice{1, 2, 3}), []float64{1, 2, 3}) + gtest.AssertEQ(j.GetMap("no", g.Map{"k": "v"}), g.Map{"k": "v"}) gtest.AssertEQ(j.GetVar("no", 123.456).Float64(), float64(123.456)) - gtest.AssertEQ(j.GetJson("no", g.Map{"k":"v"}).Get("k"), "v") + gtest.AssertEQ(j.GetJson("no", g.Map{"k": "v"}).Get("k"), "v") gtest.AssertEQ(j.GetJsons("no", g.Slice{ - g.Map{"k1":"v1"}, - g.Map{"k2":"v2"}, - g.Map{"k3":"v3"}, + g.Map{"k1": "v1"}, + g.Map{"k2": "v2"}, + g.Map{"k3": "v3"}, })[0].Get("k1"), "v1") gtest.AssertEQ(j.GetJsonMap("no", g.Map{ - "m1" : g.Map{"k1":"v1"}, - "m2" : g.Map{"k2":"v2"}, + "m1": g.Map{"k1": "v1"}, + "m2": g.Map{"k2": "v2"}, })["m2"].Get("k2"), "v2") }) } +func Test_Convert(t *testing.T) { + gtest.Case(t, func() { + j := gjson.New(`{"name":"gf"}`) + arr, err := j.ToXml() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "gf") + arr, err = j.ToXmlIndent() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "gf") + str, err := j.ToXmlString() + gtest.Assert(err == nil, true) + gtest.Assert(str, "gf") + str, err = j.ToXmlIndentString() + gtest.Assert(err == nil, true) + gtest.Assert(str, "gf") + + arr, err = j.ToJsonIndent() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}") + str, err = j.ToJsonIndentString() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}") + + arr, err = j.ToYaml() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "name: gf\n") + str, err = j.ToYamlString() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "name: gf\n") + + arr, err = j.ToToml() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "name = \"gf\"\n") + str, err = j.ToTomlString() + gtest.Assert(err == nil, true) + gtest.Assert(string(arr), "name = \"gf\"\n") + }) +} + +func Test_Convert2(t *testing.T) { + gtest.Case(t, func() { + name := struct { + Name string + }{} + j := gjson.New(`{"name":"gf","time":"2019-06-12"}`) + gtest.Assert(j.Value().(g.Map)["name"], "gf") + gtest.Assert(j.GetMap("name1"), nil) + gtest.Assert(j.GetJson("name1"), nil) + gtest.Assert(j.GetJsons("name1"), nil) + gtest.Assert(j.GetJsonMap("name1"), nil) + gtest.Assert(j.Contains("name1"), false) + gtest.Assert(j.GetToVar("name1", &name) == nil, true) + gtest.Assert(j.GetToVar("name", &name) == nil, false) + gtest.Assert(j.Len("name1"), -1) + gtest.Assert(j.GetTime("time").Format("2006-01-02"), "2019-06-12") + gtest.Assert(j.GetGTime("time").Format("Y-m-d"), "2019-06-12") + gtest.Assert(j.GetDuration("time").String(), "0s") + + err := j.ToStruct(&name) + gtest.Assert(err == nil, true) + gtest.Assert(name.Name, "gf") + err = j.Dump() + gtest.Assert(err == nil, true) + + j = gjson.New(`{"person":{"name":"gf"}}`) + err = j.GetToStruct("person", &name) + gtest.Assert(err == nil, true) + gtest.Assert(name.Name, "gf") + + j = gjson.New(`{"name":"gf""}`) + err = j.Dump() + gtest.Assert(err == nil, true) + + j = gjson.New(`[1,2,3]`) + gtest.Assert(len(j.ToArray()), 3) + }) +} + +func Test_Basic(t *testing.T) { + gtest.Case(t, func() { + j := gjson.New(`{"name":"gf","time":"2019-06-12"}`) + j.SetViolenceCheck(true) + gtest.Assert(j.Get("").(g.Map)["name"], "gf") + gtest.Assert(j.Get("").(g.Map)["name1"], nil) + j.SetViolenceCheck(false) + gtest.Assert(j.Get("").(g.Map)["name"], "gf") + + err := j.Set("name", "gf1") + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("name"), "gf1") + + j = gjson.New(`[1,2,3]`) + err = j.Set("\"0\".1", 11) + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("1"), 11) + + j = gjson.New(`[1,2,3]`) + err = j.Set("11111111111111111111111", 11) + gtest.Assert(err == nil, false) + + //此测试用例测出bug，数组下表越界，暂且注释起来， + /*j = gjson.New(`[1,2,3]`) + err = j.Remove("1") + gtest.Assert(err == nil, false) + gtest.Assert(j.Get("0"), nil)*/ + + j = gjson.New(`[1,2,3]`) + err = j.Remove("3") + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("0"), 1) + + j = gjson.New(`[1,2,3]`) + err = j.Remove("0.3") + gtest.Assert(err == nil, true) + gtest.Assert(len(j.Get("0").([]interface{})), 3) + + j = gjson.New(`[1,2,3]`) + err = j.Remove("0.a") + gtest.Assert(err == nil, true) + gtest.Assert(len(j.Get("0").(g.Map)), 0) + + name := struct { + Name string + }{Name: "gf"} + j = gjson.New(name) + gtest.Assert(j.Get("Name"), "gf") + err = j.Remove("Name") + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name"), nil) + + err = j.Set("Name", "gf1") + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name"), "gf1") + + j = gjson.New(nil) + err = j.Remove("Name") + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name"), nil) + + j = gjson.New(name) + gtest.Assert(j.Get("Name"), "gf") + err = j.Set("Name1", g.Map{"Name": "gf1"}) + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name1").(g.Map)["Name"], "gf1") + err = j.Set("Name2", g.Slice{1, 2, 3}) + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name2").(g.Slice)[0], 1) + err = j.Set("Name3", name) + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name3").(g.Map)["Name"], "gf") + err = j.Set("Name4", &name) + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name4").(g.Map)["Name"], "gf") + arr := [3]int{1, 2, 3} + err = j.Set("Name5", arr) + gtest.Assert(err == nil, true) + gtest.Assert(j.Get("Name5").(g.Array)[0], 1) + + }) +} diff --git a/g/encoding/gjson/gjson_z_unit_load_test.go b/g/encoding/gjson/gjson_z_unit_load_test.go index 6717ea124..7698f71e3 100644 --- a/g/encoding/gjson/gjson_z_unit_load_test.go +++ b/g/encoding/gjson/gjson_z_unit_load_test.go @@ -7,66 +7,65 @@ package gjson_test import ( - "github.com/gogf/gf/g" - "github.com/gogf/gf/g/encoding/gjson" - "github.com/gogf/gf/g/os/gfile" - "github.com/gogf/gf/g/test/gtest" - "testing" + "github.com/gogf/gf/g" + "github.com/gogf/gf/g/encoding/gjson" + "github.com/gogf/gf/g/os/gfile" + "github.com/gogf/gf/g/test/gtest" + "testing" ) - func Test_Load_JSON(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - // JSON - gtest.Case(t, func() { - j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) - // JSON - gtest.Case(t, func() { - path := "test.json" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gjson.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + // JSON + gtest.Case(t, func() { + j, err := gjson.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) + // JSON + gtest.Case(t, func() { + path := "test.json" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gjson.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Load_XML(t *testing.T) { - data := []byte(`123v123456789`) - // XML - gtest.Case(t, func() { - j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("doc.n"), "123456789") - gtest.Assert(j.Get("doc.m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("doc.m.k"), "v") - gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("doc.a.1"), 2) - }) - // XML - gtest.Case(t, func() { - path := "test.xml" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gjson.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("doc.n"), "123456789") - gtest.Assert(j.Get("doc.m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("doc.m.k"), "v") - gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("doc.a.1"), 2) - }) + data := []byte(`123v123456789`) + // XML + gtest.Case(t, func() { + j, err := gjson.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("doc.n"), "123456789") + gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("doc.m.k"), "v") + gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("doc.a.1"), 2) + }) + // XML + gtest.Case(t, func() { + path := "test.xml" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gjson.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("doc.n"), "123456789") + gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("doc.m.k"), "v") + gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("doc.a.1"), 2) + }) // XML gtest.Case(t, func() { @@ -82,13 +81,13 @@ func Test_Load_XML(t *testing.T) { ` j, err := gjson.LoadContent(xml) gtest.Assert(err, nil) - gtest.Assert(j.Get("Output.ipageIndex"), "2") + gtest.Assert(j.Get("Output.ipageIndex"), "2") gtest.Assert(j.Get("Output.itotalRecords"), "GF框架") }) } func Test_Load_YAML1(t *testing.T) { - data := []byte(` + data := []byte(` a: - 1 - 2 @@ -97,78 +96,102 @@ m: k: v "n": 123456789 `) - // YAML - gtest.Case(t, func() { - j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) - // YAML - gtest.Case(t, func() { - path := "test.yaml" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gjson.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + // YAML + gtest.Case(t, func() { + j, err := gjson.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) + // YAML + gtest.Case(t, func() { + path := "test.yaml" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gjson.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Load_YAML2(t *testing.T) { - data := []byte("i : 123456789") - gtest.Case(t, func() { - j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("i"), "123456789") - }) + data := []byte("i : 123456789") + gtest.Case(t, func() { + j, err := gjson.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("i"), "123456789") + }) } func Test_Load_TOML1(t *testing.T) { - data := []byte(` + data := []byte(` a = ["1", "2", "3"] n = "123456789" [m] k = "v" `) - // TOML - gtest.Case(t, func() { - j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) - // TOML - gtest.Case(t, func() { - path := "test.toml" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gjson.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + // TOML + gtest.Case(t, func() { + j, err := gjson.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) + // TOML + gtest.Case(t, func() { + path := "test.toml" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gjson.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Load_TOML2(t *testing.T) { - data := []byte("i=123456789") - gtest.Case(t, func() { - j, err := gjson.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("i"), "123456789") - }) + data := []byte("i=123456789") + gtest.Case(t, func() { + j, err := gjson.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("i"), "123456789") + }) +} + +func Test_Load_Basic(t *testing.T) { + gtest.Case(t, func() { + j := gjson.NewUnsafe() + gtest.Assert(j.Value(), nil) + _, err := gjson.Decode(nil) + gtest.Assert(err == nil, false) + _, err = gjson.DecodeToJson(nil) + gtest.Assert(err == nil, false) + j, err = gjson.LoadContent(nil) + gtest.Assert(err == nil, true) + gtest.Assert(j.Value(), nil) + + j, err = gjson.LoadContent(`{"name": "gf"}`) + gtest.Assert(err == nil, true) + + j, err = gjson.LoadContent(`{"name": "gf"""}`) + gtest.Assert(err == nil, false) + + j = gjson.New(&g.Map{"name": "gf"}) + gtest.Assert(j.GetString("name"), "gf") + + }) } diff --git a/g/encoding/gparser/gparser_unit_basic_test.go b/g/encoding/gparser/gparser_unit_basic_test.go index 4fb894d4f..cdd24599b 100644 --- a/g/encoding/gparser/gparser_unit_basic_test.go +++ b/g/encoding/gparser/gparser_unit_basic_test.go @@ -7,202 +7,314 @@ package gparser_test import ( - "github.com/gogf/gf/g" - "github.com/gogf/gf/g/encoding/gparser" - "github.com/gogf/gf/g/test/gtest" - "testing" + "github.com/gogf/gf/g" + "github.com/gogf/gf/g/encoding/gparser" + "github.com/gogf/gf/g/test/gtest" + "testing" ) func Test_New(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + v := j.Value().(g.Map) + gtest.Assert(v["n"], 123456789) + }) } func Test_NewUnsafe(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.NewUnsafe(data) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.NewUnsafe(data) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Encode(t *testing.T) { - value := g.Slice{1, 2, 3} - gtest.Case(t, func() { - b, err := gparser.VarToJson(value) - gtest.Assert(err, nil) - gtest.Assert(b, []byte(`[1,2,3]`)) - }) + value := g.Slice{1, 2, 3} + gtest.Case(t, func() { + b, err := gparser.VarToJson(value) + gtest.Assert(err, nil) + gtest.Assert(b, []byte(`[1,2,3]`)) + }) } func Test_Decode(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.AssertNE(j, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.AssertNE(j, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_SplitChar(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - j.SetSplitChar(byte('#')) - gtest.AssertNE(j, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m#k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a#1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + j.SetSplitChar(byte('#')) + gtest.AssertNE(j, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m#k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a#1"), 2) + }) } func Test_ViolenceCheck(t *testing.T) { - data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.AssertNE(j, nil) - gtest.Assert(j.Get("m.a.2"), 3) - gtest.Assert(j.Get("m.v1.v2"), nil) - j.SetViolenceCheck(true) - gtest.Assert(j.Get("m.v1.v2"), 4) - }) + data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.AssertNE(j, nil) + gtest.Assert(j.Get("m.a.2"), 3) + gtest.Assert(j.Get("m.v1.v2"), nil) + j.SetViolenceCheck(true) + gtest.Assert(j.Get("m.v1.v2"), 4) + }) } func Test_GetToVar(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - var m map[string]string - var n int - var a []int - j := gparser.New(data) - gtest.AssertNE(j, nil) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + var m map[string]string + var n int + var a []int + j := gparser.New(data) + gtest.AssertNE(j, nil) - j.GetToVar("n", &n) - j.GetToVar("m", &m) - j.GetToVar("a", &a) + j.GetToVar("n", &n) + j.GetToVar("m", &m) + j.GetToVar("a", &a) - gtest.Assert(n, "123456789") - gtest.Assert(m, g.Map{"k" : "v"}) - gtest.Assert(a, g.Slice{1, 2, 3}) - }) + gtest.Assert(n, "123456789") + gtest.Assert(m, g.Map{"k": "v"}) + gtest.Assert(a, g.Slice{1, 2, 3}) + }) } func Test_GetMap(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.AssertNE(j, nil) - gtest.Assert(j.GetMap("n"), nil) - gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"}) - gtest.Assert(j.GetMap("a"), nil) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.AssertNE(j, nil) + gtest.Assert(j.GetMap("n"), nil) + gtest.Assert(j.GetMap("m"), g.Map{"k": "v"}) + gtest.Assert(j.GetMap("a"), nil) + }) } func Test_GetArray(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.AssertNE(j, nil) - gtest.Assert(j.GetArray("n"), g.Array{123456789}) - gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k":"v"}}) - gtest.Assert(j.GetArray("a"), g.Array{1,2,3}) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.AssertNE(j, nil) + gtest.Assert(j.GetArray("n"), g.Array{123456789}) + gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k": "v"}}) + gtest.Assert(j.GetArray("a"), g.Array{1, 2, 3}) + }) } func Test_GetString(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.AssertNE(j, nil) - gtest.AssertEQ(j.GetString("n"), "123456789") - gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`) - gtest.AssertEQ(j.GetString("a"), `[1,2,3]`) - gtest.AssertEQ(j.GetString("i"), "") - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.AssertNE(j, nil) + gtest.AssertEQ(j.GetString("n"), "123456789") + gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`) + gtest.AssertEQ(j.GetString("a"), `[1,2,3]`) + gtest.AssertEQ(j.GetString("i"), "") + }) } func Test_GetStrings(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.AssertNE(j, nil) - gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"}) - gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`}) - gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"}) - gtest.AssertEQ(j.GetStrings("i"), nil) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.AssertNE(j, nil) + gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"}) + gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`}) + gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"}) + gtest.AssertEQ(j.GetStrings("i"), nil) + }) } func Test_GetInterfaces(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - gtest.Case(t, func() { - j := gparser.New(data) - gtest.AssertNE(j, nil) - gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789}) - gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k":"v"}}) - gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1,2,3}) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + gtest.Case(t, func() { + j := gparser.New(data) + gtest.AssertNE(j, nil) + gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789}) + gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k": "v"}}) + gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1, 2, 3}) + }) } func Test_Len(t *testing.T) { - gtest.Case(t, func() { - p := gparser.New(nil) - p.Append("a", 1) - p.Append("a", 2) - gtest.Assert(p.Len("a"), 2) - }) - gtest.Case(t, func() { - p := gparser.New(nil) - p.Append("a.b", 1) - p.Append("a.c", 2) - gtest.Assert(p.Len("a"), 2) - }) - gtest.Case(t, func() { - p := gparser.New(nil) - p.Set("a", 1) - gtest.Assert(p.Len("a"), -1) - }) + gtest.Case(t, func() { + p := gparser.New(nil) + p.Append("a", 1) + p.Append("a", 2) + gtest.Assert(p.Len("a"), 2) + }) + gtest.Case(t, func() { + p := gparser.New(nil) + p.Append("a.b", 1) + p.Append("a.c", 2) + gtest.Assert(p.Len("a"), 2) + }) + gtest.Case(t, func() { + p := gparser.New(nil) + p.Set("a", 1) + gtest.Assert(p.Len("a"), -1) + }) } func Test_Append(t *testing.T) { - gtest.Case(t, func() { - p := gparser.New(nil) - p.Append("a", 1) - p.Append("a", 2) - gtest.Assert(p.Get("a"), g.Slice{1, 2}) - }) - gtest.Case(t, func() { - p := gparser.New(nil) - p.Append("a.b", 1) - p.Append("a.c", 2) - gtest.Assert(p.Get("a"), g.Map{ - "b" : g.Slice{1}, - "c" : g.Slice{2}, - }) - }) - gtest.Case(t, func() { - p := gparser.New(nil) - p.Set("a", 1) - err := p.Append("a", 2) - gtest.AssertNE(err, nil) - gtest.Assert(p.Get("a"), 1) - }) + gtest.Case(t, func() { + p := gparser.New(nil) + p.Append("a", 1) + p.Append("a", 2) + gtest.Assert(p.Get("a"), g.Slice{1, 2}) + }) + gtest.Case(t, func() { + p := gparser.New(nil) + p.Append("a.b", 1) + p.Append("a.c", 2) + gtest.Assert(p.Get("a"), g.Map{ + "b": g.Slice{1}, + "c": g.Slice{2}, + }) + }) + gtest.Case(t, func() { + p := gparser.New(nil) + p.Set("a", 1) + err := p.Append("a", 2) + gtest.AssertNE(err, nil) + gtest.Assert(p.Get("a"), 1) + }) } +func Test_Convert(t *testing.T) { + gtest.Case(t, func() { + p := gparser.New(`{"name":"gf","bool":true,"int":1,"float":1,"ints":[1,2],"floats":[1,2],"time":"2019-06-12","person": {"name": "gf"}}`) + gtest.Assert(p.GetVar("name").String(), "gf") + gtest.Assert(p.GetString("name"), "gf") + gtest.Assert(p.GetBool("bool"), true) + gtest.Assert(p.GetInt("int"), 1) + gtest.Assert(p.GetInt8("int"), 1) + gtest.Assert(p.GetInt16("int"), 1) + gtest.Assert(p.GetInt32("int"), 1) + gtest.Assert(p.GetInt64("int"), 1) + gtest.Assert(p.GetUint("int"), 1) + gtest.Assert(p.GetUint8("int"), 1) + gtest.Assert(p.GetUint16("int"), 1) + gtest.Assert(p.GetUint32("int"), 1) + gtest.Assert(p.GetUint64("int"), 1) + gtest.Assert(p.GetInts("ints")[0], 1) + gtest.Assert(p.GetFloat32("float"), 1) + gtest.Assert(p.GetFloat64("float"), 1) + gtest.Assert(p.GetFloats("floats")[0], 1) + gtest.Assert(p.GetTime("time").Format("2006-01-02"), "2019-06-12") + gtest.Assert(p.GetGTime("time").Format("Y-m-d"), "2019-06-12") + gtest.Assert(p.GetDuration("time").String(), "0s") + name := struct { + Name string + }{} + err := p.GetToStruct("person", &name) + gtest.Assert(err == nil, true) + gtest.Assert(name.Name, "gf") + gtest.Assert(p.ToMap()["name"], "gf") + err = p.ToStruct(&name) + gtest.Assert(err == nil, true) + gtest.Assert(name.Name, "gf") + p.Dump() + p = gparser.New(`[0,1,2]`) + gtest.Assert(p.ToArray()[0], 0) + err = gparser.VarToStruct(`{"name":"gf"}`, &name) + gtest.Assert(err == nil, true) + gtest.Assert(name.Name, "gf") + }) +} + +func Test_Convert2(t *testing.T) { + gtest.Case(t, func() { + xmlArr := []byte{60, 114, 111, 111, 116, 47, 62} + p := gparser.New(``) + arr, err := p.ToXml("root") + gtest.Assert(err == nil, true) + gtest.Assert(arr, xmlArr) + arr, err = gparser.VarToXml(``, "root") + gtest.Assert(err == nil, true) + gtest.Assert(arr, xmlArr) + + arr, err = p.ToXmlIndent("root") + gtest.Assert(err == nil, true) + gtest.Assert(arr, xmlArr) + arr, err = gparser.VarToXmlIndent(``, "root") + gtest.Assert(err == nil, true) + gtest.Assert(arr, xmlArr) + + p = gparser.New(`{"name":"gf"}`) + str, err := p.ToJsonString() + gtest.Assert(err == nil, true) + gtest.Assert(str, `{"name":"gf"}`) + str, err = gparser.VarToJsonString(`{"name":"gf"}`) + gtest.Assert(err == nil, true) + gtest.Assert(str, `{"name":"gf"}`) + + jsonIndentArr := []byte{123, 10, 9, 34, 110, 97, 109, 101, 34, 58, 32, 34, 103, 102, 34, 10, 125} + arr, err = p.ToJsonIndent() + gtest.Assert(err == nil, true) + gtest.Assert(arr, jsonIndentArr) + arr, err = gparser.VarToJsonIndent(`{"name":"gf"}`) + gtest.Assert(err == nil, true) + gtest.Assert(arr, jsonIndentArr) + + str, err = p.ToJsonIndentString() + gtest.Assert(err == nil, true) + gtest.Assert(str, "{\n\t\"name\": \"gf\"\n}") + str, err = gparser.VarToJsonIndentString(`{"name":"gf"}`) + gtest.Assert(err == nil, true) + gtest.Assert(str, "{\n\t\"name\": \"gf\"\n}") + + yamlArr := []byte{124, 50, 10, 10, 32, 32, 110, 97, 109, 101, 58, 103, 102, 10} + p = gparser.New(` +name:gf +`) + arr, err = p.ToYaml() + gtest.Assert(err == nil, true) + gtest.Assert(arr, yamlArr) + arr, err = gparser.VarToYaml(` +name:gf +`) + gtest.Assert(err == nil, true) + gtest.Assert(arr, yamlArr) + + tomlArr := []byte{110, 97, 109, 101, 32, 61, 32, 34, 103, 102, 34, 10} + p = gparser.New(` +name= "gf" +`) + arr, err = p.ToToml() + gtest.Assert(err == nil, true) + gtest.Assert(arr, tomlArr) + arr, err = gparser.VarToToml(` +name= "gf" +`) + gtest.Assert(err == nil, true) + gtest.Assert(arr, tomlArr) + }) +} diff --git a/g/encoding/gparser/gparser_unit_load_test.go b/g/encoding/gparser/gparser_unit_load_test.go index 2702ca05f..993d7cfdf 100644 --- a/g/encoding/gparser/gparser_unit_load_test.go +++ b/g/encoding/gparser/gparser_unit_load_test.go @@ -11,62 +11,62 @@ import ( "github.com/gogf/gf/g/encoding/gparser" "github.com/gogf/gf/g/os/gfile" "github.com/gogf/gf/g/test/gtest" + "io/ioutil" "testing" ) - func Test_Load_JSON(t *testing.T) { - data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) - // JSON - gtest.Case(t, func() { - j, err := gparser.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) - // JSON - gtest.Case(t, func() { - path := "test.json" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gparser.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`) + // JSON + gtest.Case(t, func() { + j, err := gparser.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) + // JSON + gtest.Case(t, func() { + path := "test.json" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gparser.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Load_XML(t *testing.T) { - data := []byte(`123v123456789`) - // XML - gtest.Case(t, func() { - j, err := gparser.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("doc.n"), "123456789") - gtest.Assert(j.Get("doc.m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("doc.m.k"), "v") - gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("doc.a.1"), 2) - }) - // XML - gtest.Case(t, func() { - path := "test.xml" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gparser.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("doc.n"), "123456789") - gtest.Assert(j.Get("doc.m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("doc.m.k"), "v") - gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("doc.a.1"), 2) - }) + data := []byte(`123v123456789`) + // XML + gtest.Case(t, func() { + j, err := gparser.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("doc.n"), "123456789") + gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("doc.m.k"), "v") + gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("doc.a.1"), 2) + }) + // XML + gtest.Case(t, func() { + path := "test.xml" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gparser.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("doc.n"), "123456789") + gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("doc.m.k"), "v") + gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("doc.a.1"), 2) + }) // XML gtest.Case(t, func() { @@ -82,13 +82,13 @@ func Test_Load_XML(t *testing.T) { ` j, err := gparser.LoadContent(xml) gtest.Assert(err, nil) - gtest.Assert(j.Get("Output.ipageIndex"), "2") + gtest.Assert(j.Get("Output.ipageIndex"), "2") gtest.Assert(j.Get("Output.itotalRecords"), "GF框架") }) } func Test_Load_YAML1(t *testing.T) { - data := []byte(` + data := []byte(` a: - 1 - 2 @@ -97,78 +97,94 @@ m: k: v "n": 123456789 `) - // YAML - gtest.Case(t, func() { - j, err := gparser.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) - // YAML - gtest.Case(t, func() { - path := "test.yaml" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gparser.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + // YAML + gtest.Case(t, func() { + j, err := gparser.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) + // YAML + gtest.Case(t, func() { + path := "test.yaml" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gparser.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Load_YAML2(t *testing.T) { - data := []byte("i : 123456789") - gtest.Case(t, func() { - j, err := gparser.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("i"), "123456789") - }) + data := []byte("i : 123456789") + gtest.Case(t, func() { + j, err := gparser.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("i"), "123456789") + }) } func Test_Load_TOML1(t *testing.T) { - data := []byte(` + data := []byte(` a = ["1", "2", "3"] n = "123456789" [m] k = "v" `) - // TOML - gtest.Case(t, func() { - j, err := gparser.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) - // TOML - gtest.Case(t, func() { - path := "test.toml" - gfile.PutBinContents(path, data) - defer gfile.Remove(path) - j, err := gparser.Load(path) - gtest.Assert(err, nil) - gtest.Assert(j.Get("n"), "123456789") - gtest.Assert(j.Get("m"), g.Map{"k" : "v"}) - gtest.Assert(j.Get("m.k"), "v") - gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) - gtest.Assert(j.Get("a.1"), 2) - }) + // TOML + gtest.Case(t, func() { + j, err := gparser.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) + // TOML + gtest.Case(t, func() { + path := "test.toml" + gfile.PutBinContents(path, data) + defer gfile.Remove(path) + j, err := gparser.Load(path) + gtest.Assert(err, nil) + gtest.Assert(j.Get("n"), "123456789") + gtest.Assert(j.Get("m"), g.Map{"k": "v"}) + gtest.Assert(j.Get("m.k"), "v") + gtest.Assert(j.Get("a"), g.Slice{1, 2, 3}) + gtest.Assert(j.Get("a.1"), 2) + }) } func Test_Load_TOML2(t *testing.T) { - data := []byte("i=123456789") - gtest.Case(t, func() { - j, err := gparser.LoadContent(data) - gtest.Assert(err, nil) - gtest.Assert(j.Get("i"), "123456789") - }) + data := []byte("i=123456789") + gtest.Case(t, func() { + j, err := gparser.LoadContent(data) + gtest.Assert(err, nil) + gtest.Assert(j.Get("i"), "123456789") + }) +} + +func Test_Load_Nil(t *testing.T) { + gtest.Case(t, func() { + p := gparser.NewUnsafe() + gtest.Assert(p.Value(), nil) + + filePath := gfile.Pwd() + gfile.Separator + "test.json" + ioutil.WriteFile(filePath, []byte("{"), 0644) + defer gfile.Remove(filePath) + _, err := gparser.Load("test.json") + //gtest.Assert(err == nil, false) + t.Log(err) + _, err = gparser.LoadContent("{") + gtest.Assert(err == nil, false) + }) } diff --git a/g/os/gcfg/gcfg_z_unit_test.go b/g/os/gcfg/gcfg_z_unit_test.go index 91d3da165..d5a88c96f 100644 --- a/g/os/gcfg/gcfg_z_unit_test.go +++ b/g/os/gcfg/gcfg_z_unit_test.go @@ -9,14 +9,18 @@ package gcfg_test import ( - "github.com/gogf/gf/g/os/gcfg" - "github.com/gogf/gf/g/os/gfile" - "github.com/gogf/gf/g/test/gtest" - "testing" + "github.com/gogf/gf/g" + "github.com/gogf/gf/g/encoding/gjson" + "github.com/gogf/gf/g/os/gcfg" + "github.com/gogf/gf/g/os/gfile" + "github.com/gogf/gf/g/test/gtest" + "io/ioutil" + "os" + "testing" ) func Test_Basic(t *testing.T) { - config := ` + config := ` v1 = 1 v2 = "true" v3 = "off" @@ -26,58 +30,58 @@ array = [1,2,3] disk = "127.0.0.1:6379,0" cache = "127.0.0.1:6379,1" ` - gtest.Case(t, func() { - path := gcfg.DEFAULT_CONFIG_FILE - err := gfile.PutContents(path, config) - gtest.Assert(err, nil) - defer gfile.Remove(path) + gtest.Case(t, func() { + path := gcfg.DEFAULT_CONFIG_FILE + err := gfile.PutContents(path, config) + gtest.Assert(err, nil) + defer gfile.Remove(path) - c := gcfg.New() - gtest.Assert(c.Get("v1"), 1) - gtest.AssertEQ(c.GetInt("v1"), 1) - gtest.AssertEQ(c.GetInt8("v1"), int8(1)) - gtest.AssertEQ(c.GetInt16("v1"), int16(1)) - gtest.AssertEQ(c.GetInt32("v1"), int32(1)) - gtest.AssertEQ(c.GetInt64("v1"), int64(1)) - gtest.AssertEQ(c.GetUint("v1"), uint(1)) - gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) - gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) - gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) - gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) + c := gcfg.New() + gtest.Assert(c.Get("v1"), 1) + gtest.AssertEQ(c.GetInt("v1"), 1) + gtest.AssertEQ(c.GetInt8("v1"), int8(1)) + gtest.AssertEQ(c.GetInt16("v1"), int16(1)) + gtest.AssertEQ(c.GetInt32("v1"), int32(1)) + gtest.AssertEQ(c.GetInt64("v1"), int64(1)) + gtest.AssertEQ(c.GetUint("v1"), uint(1)) + gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) + gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) + gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) + gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) - gtest.AssertEQ(c.GetVar("v1").String(), "1") - gtest.AssertEQ(c.GetVar("v1").Bool(), true) - gtest.AssertEQ(c.GetVar("v2").String(), "true") - gtest.AssertEQ(c.GetVar("v2").Bool(), true) + gtest.AssertEQ(c.GetVar("v1").String(), "1") + gtest.AssertEQ(c.GetVar("v1").Bool(), true) + gtest.AssertEQ(c.GetVar("v2").String(), "true") + gtest.AssertEQ(c.GetVar("v2").Bool(), true) - gtest.AssertEQ(c.GetString("v1"), "1") - gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23)) - gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23)) - gtest.AssertEQ(c.GetString("v2"), "true") - gtest.AssertEQ(c.GetBool("v2"), true) - gtest.AssertEQ(c.GetBool("v3"), false) + gtest.AssertEQ(c.GetString("v1"), "1") + gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23)) + gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23)) + gtest.AssertEQ(c.GetString("v2"), "true") + gtest.AssertEQ(c.GetBool("v2"), true) + gtest.AssertEQ(c.GetBool("v3"), false) - gtest.AssertEQ(c.Contains("v1"), true) - gtest.AssertEQ(c.Contains("v2"), true) - gtest.AssertEQ(c.Contains("v3"), true) - gtest.AssertEQ(c.Contains("v4"), true) - gtest.AssertEQ(c.Contains("v5"), false) + gtest.AssertEQ(c.Contains("v1"), true) + gtest.AssertEQ(c.Contains("v2"), true) + gtest.AssertEQ(c.Contains("v3"), true) + gtest.AssertEQ(c.Contains("v4"), true) + gtest.AssertEQ(c.Contains("v5"), false) - gtest.AssertEQ(c.GetInts("array"), []int{1,2,3}) - gtest.AssertEQ(c.GetStrings("array"), []string{"1","2","3"}) - gtest.AssertEQ(c.GetArray("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ - "disk" : "127.0.0.1:6379,0", - "cache" : "127.0.0.1:6379,1", - }) - gtest.AssertEQ(c.FilePath(), gfile.Pwd() + gfile.Separator + path) + gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3}) + gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"}) + gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ + "disk": "127.0.0.1:6379,0", + "cache": "127.0.0.1:6379,1", + }) + gtest.AssertEQ(c.FilePath(), gfile.Pwd()+gfile.Separator+path) - }) + }) } func Test_Content(t *testing.T) { - content := ` + content := ` v1 = 1 v2 = "true" v3 = "off" @@ -87,54 +91,54 @@ array = [1,2,3] disk = "127.0.0.1:6379,0" cache = "127.0.0.1:6379,1" ` - gcfg.SetContent(content) - defer gcfg.ClearContent() + gcfg.SetContent(content) + defer gcfg.ClearContent() - gtest.Case(t, func() { - c := gcfg.New() - gtest.Assert(c.Get("v1"), 1) - gtest.AssertEQ(c.GetInt("v1"), 1) - gtest.AssertEQ(c.GetInt8("v1"), int8(1)) - gtest.AssertEQ(c.GetInt16("v1"), int16(1)) - gtest.AssertEQ(c.GetInt32("v1"), int32(1)) - gtest.AssertEQ(c.GetInt64("v1"), int64(1)) - gtest.AssertEQ(c.GetUint("v1"), uint(1)) - gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) - gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) - gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) - gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) + gtest.Case(t, func() { + c := gcfg.New() + gtest.Assert(c.Get("v1"), 1) + gtest.AssertEQ(c.GetInt("v1"), 1) + gtest.AssertEQ(c.GetInt8("v1"), int8(1)) + gtest.AssertEQ(c.GetInt16("v1"), int16(1)) + gtest.AssertEQ(c.GetInt32("v1"), int32(1)) + gtest.AssertEQ(c.GetInt64("v1"), int64(1)) + gtest.AssertEQ(c.GetUint("v1"), uint(1)) + gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) + gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) + gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) + gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) - gtest.AssertEQ(c.GetVar("v1").String(), "1") - gtest.AssertEQ(c.GetVar("v1").Bool(), true) - gtest.AssertEQ(c.GetVar("v2").String(), "true") - gtest.AssertEQ(c.GetVar("v2").Bool(), true) + gtest.AssertEQ(c.GetVar("v1").String(), "1") + gtest.AssertEQ(c.GetVar("v1").Bool(), true) + gtest.AssertEQ(c.GetVar("v2").String(), "true") + gtest.AssertEQ(c.GetVar("v2").Bool(), true) - gtest.AssertEQ(c.GetString("v1"), "1") - gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23)) - gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23)) - gtest.AssertEQ(c.GetString("v2"), "true") - gtest.AssertEQ(c.GetBool("v2"), true) - gtest.AssertEQ(c.GetBool("v3"), false) + gtest.AssertEQ(c.GetString("v1"), "1") + gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23)) + gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23)) + gtest.AssertEQ(c.GetString("v2"), "true") + gtest.AssertEQ(c.GetBool("v2"), true) + gtest.AssertEQ(c.GetBool("v3"), false) - gtest.AssertEQ(c.Contains("v1"), true) - gtest.AssertEQ(c.Contains("v2"), true) - gtest.AssertEQ(c.Contains("v3"), true) - gtest.AssertEQ(c.Contains("v4"), true) - gtest.AssertEQ(c.Contains("v5"), false) + gtest.AssertEQ(c.Contains("v1"), true) + gtest.AssertEQ(c.Contains("v2"), true) + gtest.AssertEQ(c.Contains("v3"), true) + gtest.AssertEQ(c.Contains("v4"), true) + gtest.AssertEQ(c.Contains("v5"), false) - gtest.AssertEQ(c.GetInts("array"), []int{1,2,3}) - gtest.AssertEQ(c.GetStrings("array"), []string{"1","2","3"}) - gtest.AssertEQ(c.GetArray("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ - "disk" : "127.0.0.1:6379,0", - "cache" : "127.0.0.1:6379,1", - }) - }) + gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3}) + gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"}) + gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ + "disk": "127.0.0.1:6379,0", + "cache": "127.0.0.1:6379,1", + }) + }) } func Test_SetFileName(t *testing.T) { - config := ` + config := ` { "array": [ 1, @@ -151,59 +155,59 @@ func Test_SetFileName(t *testing.T) { "v4": "1.234" } ` - gtest.Case(t, func() { - path := "config.json" - err := gfile.PutContents(path, config) - gtest.Assert(err, nil) - defer gfile.Remove(path) + gtest.Case(t, func() { + path := "config.json" + err := gfile.PutContents(path, config) + gtest.Assert(err, nil) + defer gfile.Remove(path) - c := gcfg.New() - c.SetFileName(path) - gtest.Assert(c.Get("v1"), 1) - gtest.AssertEQ(c.GetInt("v1"), 1) - gtest.AssertEQ(c.GetInt8("v1"), int8(1)) - gtest.AssertEQ(c.GetInt16("v1"), int16(1)) - gtest.AssertEQ(c.GetInt32("v1"), int32(1)) - gtest.AssertEQ(c.GetInt64("v1"), int64(1)) - gtest.AssertEQ(c.GetUint("v1"), uint(1)) - gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) - gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) - gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) - gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) + c := gcfg.New() + c.SetFileName(path) + gtest.Assert(c.Get("v1"), 1) + gtest.AssertEQ(c.GetInt("v1"), 1) + gtest.AssertEQ(c.GetInt8("v1"), int8(1)) + gtest.AssertEQ(c.GetInt16("v1"), int16(1)) + gtest.AssertEQ(c.GetInt32("v1"), int32(1)) + gtest.AssertEQ(c.GetInt64("v1"), int64(1)) + gtest.AssertEQ(c.GetUint("v1"), uint(1)) + gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) + gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) + gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) + gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) - gtest.AssertEQ(c.GetVar("v1").String(), "1") - gtest.AssertEQ(c.GetVar("v1").Bool(), true) - gtest.AssertEQ(c.GetVar("v2").String(), "true") - gtest.AssertEQ(c.GetVar("v2").Bool(), true) + gtest.AssertEQ(c.GetVar("v1").String(), "1") + gtest.AssertEQ(c.GetVar("v1").Bool(), true) + gtest.AssertEQ(c.GetVar("v2").String(), "true") + gtest.AssertEQ(c.GetVar("v2").Bool(), true) - gtest.AssertEQ(c.GetString("v1"), "1") - gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234)) - gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234)) - gtest.AssertEQ(c.GetString("v2"), "true") - gtest.AssertEQ(c.GetBool("v2"), true) - gtest.AssertEQ(c.GetBool("v3"), false) + gtest.AssertEQ(c.GetString("v1"), "1") + gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234)) + gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234)) + gtest.AssertEQ(c.GetString("v2"), "true") + gtest.AssertEQ(c.GetBool("v2"), true) + gtest.AssertEQ(c.GetBool("v3"), false) - gtest.AssertEQ(c.Contains("v1"), true) - gtest.AssertEQ(c.Contains("v2"), true) - gtest.AssertEQ(c.Contains("v3"), true) - gtest.AssertEQ(c.Contains("v4"), true) - gtest.AssertEQ(c.Contains("v5"), false) + gtest.AssertEQ(c.Contains("v1"), true) + gtest.AssertEQ(c.Contains("v2"), true) + gtest.AssertEQ(c.Contains("v3"), true) + gtest.AssertEQ(c.Contains("v4"), true) + gtest.AssertEQ(c.Contains("v5"), false) - gtest.AssertEQ(c.GetInts("array"), []int{1,2,3}) - gtest.AssertEQ(c.GetStrings("array"), []string{"1","2","3"}) - gtest.AssertEQ(c.GetArray("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ - "disk" : "127.0.0.1:6379,0", - "cache" : "127.0.0.1:6379,1", - }) - gtest.AssertEQ(c.FilePath(), gfile.Pwd() + gfile.Separator + path) + gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3}) + gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"}) + gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ + "disk": "127.0.0.1:6379,0", + "cache": "127.0.0.1:6379,1", + }) + gtest.AssertEQ(c.FilePath(), gfile.Pwd()+gfile.Separator+path) - }) + }) } func Test_Instance(t *testing.T) { - config := ` + config := ` { "array": [ 1, @@ -220,52 +224,183 @@ func Test_Instance(t *testing.T) { "v4": "1.234" } ` - gtest.Case(t, func() { - path := gcfg.DEFAULT_CONFIG_FILE - err := gfile.PutContents(path, config) - gtest.Assert(err, nil) - defer gfile.Remove(path) + gtest.Case(t, func() { + path := gcfg.DEFAULT_CONFIG_FILE + err := gfile.PutContents(path, config) + gtest.Assert(err, nil) + defer gfile.Remove(path) - c := gcfg.Instance() - gtest.Assert(c.Get("v1"), 1) - gtest.AssertEQ(c.GetInt("v1"), 1) - gtest.AssertEQ(c.GetInt8("v1"), int8(1)) - gtest.AssertEQ(c.GetInt16("v1"), int16(1)) - gtest.AssertEQ(c.GetInt32("v1"), int32(1)) - gtest.AssertEQ(c.GetInt64("v1"), int64(1)) - gtest.AssertEQ(c.GetUint("v1"), uint(1)) - gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) - gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) - gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) - gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) + c := gcfg.Instance() + gtest.Assert(c.Get("v1"), 1) + gtest.AssertEQ(c.GetInt("v1"), 1) + gtest.AssertEQ(c.GetInt8("v1"), int8(1)) + gtest.AssertEQ(c.GetInt16("v1"), int16(1)) + gtest.AssertEQ(c.GetInt32("v1"), int32(1)) + gtest.AssertEQ(c.GetInt64("v1"), int64(1)) + gtest.AssertEQ(c.GetUint("v1"), uint(1)) + gtest.AssertEQ(c.GetUint8("v1"), uint8(1)) + gtest.AssertEQ(c.GetUint16("v1"), uint16(1)) + gtest.AssertEQ(c.GetUint32("v1"), uint32(1)) + gtest.AssertEQ(c.GetUint64("v1"), uint64(1)) - gtest.AssertEQ(c.GetVar("v1").String(), "1") - gtest.AssertEQ(c.GetVar("v1").Bool(), true) - gtest.AssertEQ(c.GetVar("v2").String(), "true") - gtest.AssertEQ(c.GetVar("v2").Bool(), true) + gtest.AssertEQ(c.GetVar("v1").String(), "1") + gtest.AssertEQ(c.GetVar("v1").Bool(), true) + gtest.AssertEQ(c.GetVar("v2").String(), "true") + gtest.AssertEQ(c.GetVar("v2").Bool(), true) - gtest.AssertEQ(c.GetString("v1"), "1") - gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234)) - gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234)) - gtest.AssertEQ(c.GetString("v2"), "true") - gtest.AssertEQ(c.GetBool("v2"), true) - gtest.AssertEQ(c.GetBool("v3"), false) + gtest.AssertEQ(c.GetString("v1"), "1") + gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234)) + gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234)) + gtest.AssertEQ(c.GetString("v2"), "true") + gtest.AssertEQ(c.GetBool("v2"), true) + gtest.AssertEQ(c.GetBool("v3"), false) - gtest.AssertEQ(c.Contains("v1"), true) - gtest.AssertEQ(c.Contains("v2"), true) - gtest.AssertEQ(c.Contains("v3"), true) - gtest.AssertEQ(c.Contains("v4"), true) - gtest.AssertEQ(c.Contains("v5"), false) + gtest.AssertEQ(c.Contains("v1"), true) + gtest.AssertEQ(c.Contains("v2"), true) + gtest.AssertEQ(c.Contains("v3"), true) + gtest.AssertEQ(c.Contains("v4"), true) + gtest.AssertEQ(c.Contains("v5"), false) - gtest.AssertEQ(c.GetInts("array"), []int{1,2,3}) - gtest.AssertEQ(c.GetStrings("array"), []string{"1","2","3"}) - gtest.AssertEQ(c.GetArray("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1","2","3"}) - gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ - "disk" : "127.0.0.1:6379,0", - "cache" : "127.0.0.1:6379,1", - }) - gtest.AssertEQ(c.FilePath(), gfile.Pwd() + gfile.Separator + path) + gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3}) + gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"}) + gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"}) + gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{ + "disk": "127.0.0.1:6379,0", + "cache": "127.0.0.1:6379,1", + }) + gtest.AssertEQ(c.FilePath(), gfile.Pwd()+gfile.Separator+path) - }) -} \ No newline at end of file + }) +} + +func TestCfg_New(t *testing.T) { + gtest.Case(t, func() { + os.Setenv("GF_GCFG_PATH", "config") + c := gcfg.New("config.yml") + gtest.Assert(c.Get("name"), nil) + gtest.Assert(c.GetFileName(), "config.yml") + + configPath := gfile.Pwd() + gfile.Separator + "config" + gfile.Mkdir(configPath) + defer gfile.Remove(configPath) + c = gcfg.New("config.yml") + gtest.Assert(c.Get("name"), nil) + + os.Unsetenv("GF_GCFG_PATH") + c = gcfg.New("config.yml") + gtest.Assert(c.Get("name"), nil) + }) +} + +func TestCfg_SetPath(t *testing.T) { + gtest.Case(t, func() { + c := gcfg.New("config.yml") + err := c.SetPath("tmp") + gtest.Assert(err == nil, false) + err = c.SetPath("gcfg.go") + gtest.Assert(err == nil, false) + gtest.Assert(c.Get("name"), nil) + }) +} + +func TestCfg_SetViolenceCheck(t *testing.T) { + gtest.Case(t, func() { + c := gcfg.New("config.yml") + c.SetViolenceCheck(true) + gtest.Assert(c.Get("name"), nil) + }) +} + +func TestCfg_AddPath(t *testing.T) { + gtest.Case(t, func() { + c := gcfg.New("config.yml") + err := c.AddPath("tmp") + gtest.Assert(err == nil, false) + err = c.AddPath("gcfg.go") + gtest.Assert(err == nil, false) + gtest.Assert(c.Get("name"), nil) + }) +} + +func TestCfg_FilePath(t *testing.T) { + gtest.Case(t, func() { + c := gcfg.New("config.yml") + path := c.FilePath("tmp") + gtest.Assert(path, "") + path = c.GetFilePath("tmp") + gtest.Assert(path, "") + }) +} + +func TestCfg_Get(t *testing.T) { + gtest.Case(t, func() { + configPath := gfile.Pwd() + gfile.Separator + "config" + gfile.Mkdir(configPath) + defer gfile.Remove(configPath) + ioutil.WriteFile(configPath+gfile.Separator+"config.yml", []byte("wrong config"), 0644) + c := gcfg.New("config.yml") + gtest.Assert(c.Get("name"), nil) + gtest.Assert(c.GetVar("name").Val(), nil) + gtest.Assert(c.Contains("name"), false) + gtest.Assert(c.GetMap("name"), nil) + gtest.Assert(c.GetArray("name"), nil) + gtest.Assert(c.GetString("name"), "") + gtest.Assert(c.GetStrings("name"), nil) + gtest.Assert(c.GetInterfaces("name"), nil) + gtest.Assert(c.GetBool("name"), false) + gtest.Assert(c.GetFloat32("name"), 0) + gtest.Assert(c.GetFloat64("name"), 0) + gtest.Assert(c.GetFloats("name"), nil) + gtest.Assert(c.GetInt("name"), 0) + gtest.Assert(c.GetInt8("name"), 0) + gtest.Assert(c.GetInt16("name"), 0) + gtest.Assert(c.GetInt32("name"), 0) + gtest.Assert(c.GetInt64("name"), 0) + gtest.Assert(c.GetInts("name"), nil) + gtest.Assert(c.GetUint("name"), 0) + gtest.Assert(c.GetUint8("name"), 0) + gtest.Assert(c.GetUint16("name"), 0) + gtest.Assert(c.GetUint32("name"), 0) + gtest.Assert(c.GetUint64("name"), 0) + gtest.Assert(c.GetTime("name").Format("2006-01-02"), "0001-01-01") + gtest.Assert(c.GetGTime("name"), nil) + gtest.Assert(c.GetDuration("name").String(), "0s") + name := struct { + Name string + }{} + gtest.Assert(c.GetToStruct("name", &name) == nil, false) + + c.Reload() + c.Clear() + + arr, _ := gjson.Encode(g.Map{"name": "gf", "time": "2019-06-12", "person": g.Map{"name": "gf"}, "floats": g.Slice{1, 2, 3}}) + ioutil.WriteFile(configPath+gfile.Separator+"config.yml", arr, 0644) + gtest.Assert(c.GetTime("time").Format("2006-01-02"), "2019-06-12") + gtest.Assert(c.GetGTime("time").Format("Y-m-d"), "2019-06-12") + gtest.Assert(c.GetDuration("time").String(), "0s") + t.Log(c.GetString("person")) + err := c.GetToStruct("person", &name) + gtest.Assert(err == nil, true) + gtest.Assert(name.Name, "gf") + gtest.Assert(c.GetFloats("floats") == nil, false) + }) +} + +func TestCfg_Instance(t *testing.T) { + gtest.Case(t, func() { + gtest.Assert(gcfg.Instance("gf") != nil, true) + }) +} + +func TestCfg_Config(t *testing.T) { + gtest.Case(t, func() { + gcfg.SetContent("gf", "config.yml") + gtest.Assert(gcfg.GetContent("config.yml"), "gf") + gcfg.SetContent("gf1", "config.yml") + gtest.Assert(gcfg.GetContent("config.yml"), "gf1") + gcfg.RemoveConfig("config.yml") + gcfg.ClearContent() + gtest.Assert(gcfg.GetContent("name"), "") + }) +}