From 3a7268677424514fa09e05c55c8c77499c2402a3 Mon Sep 17 00:00:00 2001 From: zhangbiao Date: Mon, 10 Jun 2019 15:05:11 +0800 Subject: [PATCH 01/13] add gcrc test --- g/crypto/gcrc32/gcrc32_test.go | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/g/crypto/gcrc32/gcrc32_test.go b/g/crypto/gcrc32/gcrc32_test.go index 32f9a3094..27c301fbc 100644 --- a/g/crypto/gcrc32/gcrc32_test.go +++ b/g/crypto/gcrc32/gcrc32_test.go @@ -15,7 +15,7 @@ import ( "github.com/gogf/gf/g/test/gtest" ) -func TestEncrypt(t *testing.T) { +func TestEncryptString(t *testing.T) { gtest.Case(t, func() { s := "pibigstar" result := 693191136 @@ -25,3 +25,14 @@ func TestEncrypt(t *testing.T) { gtest.AssertEQ(int(encrypt2), result) }) } + +func TestEncrypt(t *testing.T) { + gtest.Case(t, func() { + s := "pibigstar" + result := 693191136 + encrypt1 := gcrc32.Encrypt(s) + encrypt2 := gcrc32.Encrypt([]byte(s)) + gtest.AssertEQ(int(encrypt1), result) + gtest.AssertEQ(int(encrypt2), result) + }) +} From d5d14b7efc73153d8ac17553c813d3be69961143 Mon Sep 17 00:00:00 2001 From: zdl <381897429@qq.com> Date: Mon, 10 Jun 2019 15:49:43 +0800 Subject: [PATCH 02/13] test gset TestSet_New --- g/container/gset/gset_z_unit_test.go | 262 ++++++++++++++------------- 1 file changed, 141 insertions(+), 121 deletions(-) diff --git a/g/container/gset/gset_z_unit_test.go b/g/container/gset/gset_z_unit_test.go index a0901a070..9ee7c192e 100644 --- a/g/container/gset/gset_z_unit_test.go +++ b/g/container/gset/gset_z_unit_test.go @@ -9,152 +9,172 @@ package gset_test import ( - "github.com/gogf/gf/g/container/garray" - "github.com/gogf/gf/g/container/gset" - "github.com/gogf/gf/g/test/gtest" - "testing" + "github.com/gogf/gf/g/container/garray" + "github.com/gogf/gf/g/container/gset" + "github.com/gogf/gf/g/test/gtest" + "testing" ) +func TestSet_New(t *testing.T) { + gtest.Case(t, func() { + s := gset.New() + s.Add(1).Add(1).Add(2) + s.Add([]interface{}{3, 4}...) + gtest.Assert(s.Size(), 4) + gtest.AssertIN(1, s.Slice()) + gtest.AssertIN(2, s.Slice()) + gtest.AssertIN(3, s.Slice()) + gtest.AssertIN(4, s.Slice()) + gtest.AssertNI(0, s.Slice()) + gtest.Assert(s.Contains(4), true) + gtest.Assert(s.Contains(5), false) + s.Remove(1) + gtest.Assert(s.Size(), 3) + s.Clear() + gtest.Assert(s.Size(), 0) + }) +} + func TestSet_Basic(t *testing.T) { - gtest.Case(t, func() { - s := gset.NewSet() - s.Add(1).Add(1).Add(2) - s.Add([]interface{}{3,4}...) - gtest.Assert(s.Size(), 4) - gtest.AssertIN(1, s.Slice()) - gtest.AssertIN(2, s.Slice()) - gtest.AssertIN(3, s.Slice()) - gtest.AssertIN(4, s.Slice()) - gtest.AssertNI(0, s.Slice()) - gtest.Assert(s.Contains(4), true) - gtest.Assert(s.Contains(5), false) - s.Remove(1) - gtest.Assert(s.Size(), 3) - s.Clear() - gtest.Assert(s.Size(), 0) - }) + gtest.Case(t, func() { + s := gset.NewSet() + s.Add(1).Add(1).Add(2) + s.Add([]interface{}{3, 4}...) + gtest.Assert(s.Size(), 4) + gtest.AssertIN(1, s.Slice()) + gtest.AssertIN(2, s.Slice()) + gtest.AssertIN(3, s.Slice()) + gtest.AssertIN(4, s.Slice()) + gtest.AssertNI(0, s.Slice()) + gtest.Assert(s.Contains(4), true) + gtest.Assert(s.Contains(5), false) + s.Remove(1) + gtest.Assert(s.Size(), 3) + s.Clear() + gtest.Assert(s.Size(), 0) + }) } func TestSet_Iterator(t *testing.T) { - gtest.Case(t, func() { - s := gset.NewSet() - s.Add(1).Add(2).Add(3) - gtest.Assert(s.Size(), 3) + gtest.Case(t, func() { + s := gset.NewSet() + s.Add(1).Add(2).Add(3) + gtest.Assert(s.Size(), 3) - a1 := garray.New() - a2 := garray.New() - s.Iterator(func(v interface{}) bool { - a1.Append(1) - return false - }) - s.Iterator(func(v interface{}) bool { - a2.Append(1) - return true - }) - gtest.Assert(a1.Len(), 1) - gtest.Assert(a2.Len(), 3) - }) + a1 := garray.New() + a2 := garray.New() + s.Iterator(func(v interface{}) bool { + a1.Append(1) + return false + }) + s.Iterator(func(v interface{}) bool { + a2.Append(1) + return true + }) + gtest.Assert(a1.Len(), 1) + gtest.Assert(a2.Len(), 3) + }) } func TestSet_LockFunc(t *testing.T) { - gtest.Case(t, func() { - s := gset.NewSet() - s.Add(1).Add(2).Add(3) - gtest.Assert(s.Size(), 3) - s.LockFunc(func(m map[interface{}]struct{}) { - delete(m, 1) - }) - gtest.Assert(s.Size(), 2) - s.RLockFunc(func(m map[interface{}]struct{}) { - gtest.Assert(m, map[interface{}]struct{}{ - 3 : struct{}{}, - 2 : struct{}{}, - }) - }) - }) + gtest.Case(t, func() { + s := gset.NewSet() + s.Add(1).Add(2).Add(3) + gtest.Assert(s.Size(), 3) + s.LockFunc(func(m map[interface{}]struct{}) { + delete(m, 1) + }) + gtest.Assert(s.Size(), 2) + s.RLockFunc(func(m map[interface{}]struct{}) { + gtest.Assert(m, map[interface{}]struct{}{ + 3: struct{}{}, + 2: struct{}{}, + }) + }) + }) } func TestSet_Equal(t *testing.T) { - gtest.Case(t, func() { - s1 := gset.NewSet() - s2 := gset.NewSet() - s3 := gset.NewSet() - s1.Add(1).Add(2).Add(3) - s2.Add(1).Add(2).Add(3) - s3.Add(1).Add(2).Add(3).Add(4) - gtest.Assert(s1.Equal(s2), true) - gtest.Assert(s1.Equal(s3), false) - }) + gtest.Case(t, func() { + s1 := gset.NewSet() + s2 := gset.NewSet() + s3 := gset.NewSet() + s1.Add(1).Add(2).Add(3) + s2.Add(1).Add(2).Add(3) + s3.Add(1).Add(2).Add(3).Add(4) + gtest.Assert(s1.Equal(s2), true) + gtest.Assert(s1.Equal(s3), false) + }) } func TestSet_IsSubsetOf(t *testing.T) { - gtest.Case(t, func() { - s1 := gset.NewSet() - s2 := gset.NewSet() - s3 := gset.NewSet() - s1.Add(1).Add(2) - s2.Add(1).Add(2).Add(3) - s3.Add(1).Add(2).Add(3).Add(4) - gtest.Assert(s1.IsSubsetOf(s2), true) - gtest.Assert(s2.IsSubsetOf(s3), true) - gtest.Assert(s1.IsSubsetOf(s3), true) - gtest.Assert(s2.IsSubsetOf(s1), false) - gtest.Assert(s3.IsSubsetOf(s2), false) - }) + gtest.Case(t, func() { + s1 := gset.NewSet() + s2 := gset.NewSet() + s3 := gset.NewSet() + s1.Add(1).Add(2) + s2.Add(1).Add(2).Add(3) + s3.Add(1).Add(2).Add(3).Add(4) + gtest.Assert(s1.IsSubsetOf(s2), true) + gtest.Assert(s2.IsSubsetOf(s3), true) + gtest.Assert(s1.IsSubsetOf(s3), true) + gtest.Assert(s2.IsSubsetOf(s1), false) + gtest.Assert(s3.IsSubsetOf(s2), false) + }) } func TestSet_Union(t *testing.T) { - gtest.Case(t, func() { - s1 := gset.NewSet() - s2 := gset.NewSet() - s1.Add(1).Add(2) - s2.Add(3).Add(4) - s3 := s1.Union(s2) - gtest.Assert(s3.Contains(1), true) - gtest.Assert(s3.Contains(2), true) - gtest.Assert(s3.Contains(3), true) - gtest.Assert(s3.Contains(4), true) - }) + gtest.Case(t, func() { + s1 := gset.NewSet() + s2 := gset.NewSet() + s1.Add(1).Add(2) + s2.Add(3).Add(4) + s3 := s1.Union(s2) + gtest.Assert(s3.Contains(1), true) + gtest.Assert(s3.Contains(2), true) + gtest.Assert(s3.Contains(3), true) + gtest.Assert(s3.Contains(4), true) + }) } func TestSet_Diff(t *testing.T) { - gtest.Case(t, func() { - s1 := gset.NewSet() - s2 := gset.NewSet() - s1.Add(1).Add(2).Add(3) - s2.Add(3).Add(4).Add(5) - s3 := s1.Diff(s2) - gtest.Assert(s3.Contains(1), true) - gtest.Assert(s3.Contains(2), true) - gtest.Assert(s3.Contains(3), false) - gtest.Assert(s3.Contains(4), false) - }) + gtest.Case(t, func() { + s1 := gset.NewSet() + s2 := gset.NewSet() + s1.Add(1).Add(2).Add(3) + s2.Add(3).Add(4).Add(5) + s3 := s1.Diff(s2) + gtest.Assert(s3.Contains(1), true) + gtest.Assert(s3.Contains(2), true) + gtest.Assert(s3.Contains(3), false) + gtest.Assert(s3.Contains(4), false) + }) } func TestSet_Intersect(t *testing.T) { - gtest.Case(t, func() { - s1 := gset.NewSet() - s2 := gset.NewSet() - s1.Add(1).Add(2).Add(3) - s2.Add(3).Add(4).Add(5) - s3 := s1.Intersect(s2) - gtest.Assert(s3.Contains(1), false) - gtest.Assert(s3.Contains(2), false) - gtest.Assert(s3.Contains(3), true) - gtest.Assert(s3.Contains(4), false) - }) + gtest.Case(t, func() { + s1 := gset.NewSet() + s2 := gset.NewSet() + s1.Add(1).Add(2).Add(3) + s2.Add(3).Add(4).Add(5) + s3 := s1.Intersect(s2) + gtest.Assert(s3.Contains(1), false) + gtest.Assert(s3.Contains(2), false) + gtest.Assert(s3.Contains(3), true) + gtest.Assert(s3.Contains(4), false) + }) } func TestSet_Complement(t *testing.T) { - gtest.Case(t, func() { - s1 := gset.NewSet() - s2 := gset.NewSet() - s1.Add(1).Add(2).Add(3) - s2.Add(3).Add(4).Add(5) - s3 := s1.Complement(s2) - gtest.Assert(s3.Contains(1), false) - gtest.Assert(s3.Contains(2), false) - gtest.Assert(s3.Contains(4), true) - gtest.Assert(s3.Contains(5), true) - }) -} \ No newline at end of file + gtest.Case(t, func() { + s1 := gset.NewSet() + s2 := gset.NewSet() + s1.Add(1).Add(2).Add(3) + s2.Add(3).Add(4).Add(5) + s3 := s1.Complement(s2) + gtest.Assert(s3.Contains(1), false) + gtest.Assert(s3.Contains(2), false) + gtest.Assert(s3.Contains(4), true) + gtest.Assert(s3.Contains(5), true) + }) +} From 6814372a891b699ecdd0085768dfd223f612a6cd Mon Sep 17 00:00:00 2001 From: zhangbiao Date: Mon, 10 Jun 2019 15:55:43 +0800 Subject: [PATCH 03/13] add gcrc test2 --- g/crypto/gcrc32/gcrc32_test.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/g/crypto/gcrc32/gcrc32_test.go b/g/crypto/gcrc32/gcrc32_test.go index 27c301fbc..7a67d1c41 100644 --- a/g/crypto/gcrc32/gcrc32_test.go +++ b/g/crypto/gcrc32/gcrc32_test.go @@ -9,6 +9,7 @@ package gcrc32_test import ( + "github.com/gogf/gf/g/crypto/gmd5" "testing" "github.com/gogf/gf/g/crypto/gcrc32" @@ -34,5 +35,10 @@ func TestEncrypt(t *testing.T) { encrypt2 := gcrc32.Encrypt([]byte(s)) gtest.AssertEQ(int(encrypt1), result) gtest.AssertEQ(int(encrypt2), result) + + strmd5 := gmd5.Encrypt(s) + test1 := gcrc32.Encrypt(strmd5) + test2 := gcrc32.Encrypt([]byte(strmd5)) + gtest.AssertEQ(test2, test1) }) } From 501c3680d931bb998950662196c48b2de8315e3d Mon Sep 17 00:00:00 2001 From: zhangbiao Date: Mon, 10 Jun 2019 17:26:32 +0800 Subject: [PATCH 04/13] add gaes test --- g/crypto/gaes/gaes_test.go | 58 ++++++++++++++++++++++++++++++++++---- 1 file changed, 53 insertions(+), 5 deletions(-) diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go index fbae75d9c..1a3fb24da 100644 --- a/g/crypto/gaes/gaes_test.go +++ b/g/crypto/gaes/gaes_test.go @@ -18,11 +18,14 @@ import ( var ( content = []byte("pibigstar") // iv 长度必须等于blockSize，只能为16 - iv = []byte("Hello My GoFrame") - key_16 = []byte("1234567891234567") - key_24 = []byte("123456789123456789123456") - key_32 = []byte("12345678912345678912345678912345") - keys = []byte("12345678912345678912345678912346") + iv = []byte("Hello My GoFrame") + key_16 = []byte("1234567891234567") + key_17 = []byte("12345678912345670") + key_24 = []byte("123456789123456789123456") + key_32 = []byte("12345678912345678912345678912345") + keys = []byte("12345678912345678912345678912346") + key_err = []byte("1234") + key_32_err = []byte("1234567891234567891234567891234 ") ) func TestEncrypt(t *testing.T) { @@ -38,6 +41,51 @@ func TestEncrypt(t *testing.T) { }) } +func TestEncryptErr(t *testing.T) { + gtest.Case(t, func() { + // encrypt key error + _, err := gaes.Encrypt(content, key_err) + gtest.AssertNE(err, nil) + }) +} + +func TestDecryptErr(t *testing.T) { + gtest.Case(t, func() { + // decrypt key error + encrypt, err := gaes.Encrypt(content, key_16) + _, err = gaes.Decrypt(encrypt, key_err) + gtest.AssertNE(err, nil) + + // decrypt content too short error + _, err = gaes.Decrypt([]byte("test"), key_16) + gtest.AssertNE(err, nil) + + // decrypt content size error + _, err = gaes.Decrypt(key_17, key_16) + gtest.AssertNE(err, nil) + }) +} + +func TestPKCS5UnPaddingErr(t *testing.T) { + gtest.Case(t, func() { + // PKCS5UnPadding blockSize zero + _, err := gaes.PKCS5UnPadding(content, 0) + gtest.AssertNE(err, nil) + + // PKCS5UnPadding src len zero + _, err = gaes.PKCS5UnPadding([]byte(""), 16) + gtest.AssertNE(err, nil) + + // PKCS5UnPadding src len > blockSize + _, err = gaes.PKCS5UnPadding(key_17, 16) + gtest.AssertNE(err, nil) + + // PKCS5UnPadding src len > blockSize + _, err = gaes.PKCS5UnPadding(key_32_err, 32) + gtest.AssertNE(err, nil) + }) +} + func TestDecrypt(t *testing.T) { gtest.Case(t, func() { encrypt, err := gaes.Encrypt(content, key_16) From 334cd7ad515ec4c553bd3acc5cfa21e1ddedd8df Mon Sep 17 00:00:00 2001 From: zhangbiao Date: Mon, 10 Jun 2019 18:59:42 +0800 Subject: [PATCH 05/13] add gregex test --- g/text/gregex/gregex_z_unit_test.go | 49 +++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/g/text/gregex/gregex_z_unit_test.go b/g/text/gregex/gregex_z_unit_test.go index 64ce85489..bd2556b3b 100644 --- a/g/text/gregex/gregex_z_unit_test.go +++ b/g/text/gregex/gregex_z_unit_test.go @@ -15,6 +15,10 @@ import ( "testing" ) +var ( + PatternErr = `([\d+` +) + func Test_Quote(t *testing.T) { gtest.Case(t, func() { s1 := `[foo]` //`\[foo\]` @@ -40,6 +44,8 @@ func Test_IsMatch(t *testing.T) { gtest.Assert(gregex.IsMatch(pattern, s1), false) s1 = []byte(`sfs:`) gtest.Assert(gregex.IsMatch(pattern, s1), false) + // error pattern + gtest.Assert(gregex.IsMatch(PatternErr, s1), false) }) } @@ -52,6 +58,8 @@ func Test_IsMatchString(t *testing.T) { gtest.Assert(gregex.IsMatchString(pattern, s1), false) s1 = `sfs:` gtest.Assert(gregex.IsMatchString(pattern, s1), false) + // error pattern + gtest.Assert(gregex.IsMatchString(PatternErr, s1), false) }) } @@ -68,6 +76,9 @@ func Test_Match(t *testing.T) { if string(subs[1]) != "aab" { t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab") } + // error pattern + _, err = gregex.Match(PatternErr, []byte(s)) + gtest.AssertNE(err, nil) }) } @@ -84,6 +95,9 @@ func Test_MatchString(t *testing.T) { if string(subs[1]) != "aab" { t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab") } + // error pattern + _, err = gregex.MatchString(PatternErr, s) + gtest.AssertNE(err, nil) }) } @@ -108,6 +122,9 @@ func Test_MatchAll(t *testing.T) { if string(subs[1][1]) != "aab" { t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab") } + // error pattern + _, err = gregex.MatchAll(PatternErr, []byte(s)) + gtest.AssertNE(err, nil) }) } @@ -131,6 +148,9 @@ func Test_MatchAllString(t *testing.T) { if string(subs[1][1]) != "aab" { t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab") } + // error pattern + _, err = gregex.MatchAllString(PatternErr, s) + gtest.AssertNE(err, nil) }) } @@ -146,6 +166,9 @@ func Test_Replace(t *testing.T) { if string(replacedStr) != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } + // error pattern + _, err = gregex.Replace(PatternErr, []byte(replace), []byte(s)) + gtest.AssertNE(err, nil) }) } @@ -161,6 +184,9 @@ func Test_ReplaceString(t *testing.T) { if replacedStr != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } + // error pattern + _, err = gregex.ReplaceString(PatternErr, replace, s) + gtest.AssertNE(err, nil) }) } @@ -182,6 +208,11 @@ func Test_ReplaceFun(t *testing.T) { if string(replacedStr) != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } + // error pattern + _, err = gregex.ReplaceFunc(PatternErr, []byte(s), func(s []byte) []byte { + return []byte("") + }) + gtest.AssertNE(err, nil) }) } @@ -209,6 +240,11 @@ func Test_ReplaceFuncMatch(t *testing.T) { }) gtest.Assert(e3, nil) gtest.Assert(s3, []byte("7890")) + // error pattern + _, err := gregex.ReplaceFuncMatch(PatternErr, s, func(match [][]byte) []byte { + return match[3] + }) + gtest.AssertNE(err, nil) }) } @@ -230,6 +266,11 @@ func Test_ReplaceStringFunc(t *testing.T) { if replacedStr != wanted { t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted) } + // error pattern + _, err = gregex.ReplaceStringFunc(PatternErr, s, func(s string) string { + return "" + }) + gtest.AssertNE(err, nil) }) } @@ -257,6 +298,11 @@ func Test_ReplaceStringFuncMatch(t *testing.T) { }) gtest.Assert(e3, nil) gtest.Assert(s3, "7890") + // error pattern + _, err := gregex.ReplaceStringFuncMatch(PatternErr, s, func(match []string) string { + return "" + }) + gtest.AssertNE(err, nil) }) } @@ -288,6 +334,9 @@ func Test_Split(t *testing.T) { if items[0] != s { t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0) } + // error pattern + items = gregex.Split(PatternErr, s) + gtest.AssertEQ(items, nil) }) } From 59ae6217cddf7c589ad80b3b6a29129de32f414a Mon Sep 17 00:00:00 2001 From: zhangbiao Date: Mon, 10 Jun 2019 19:37:02 +0800 Subject: [PATCH 06/13] add gaes test3: add encrypt assert content --- g/crypto/gaes/gaes_test.go | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go index 1a3fb24da..36f0101a7 100644 --- a/g/crypto/gaes/gaes_test.go +++ b/g/crypto/gaes/gaes_test.go @@ -9,6 +9,7 @@ package gaes_test import ( + "github.com/gogf/gf/g/encoding/gbase64" "testing" "github.com/gogf/gf/g/crypto/gaes" @@ -16,7 +17,11 @@ import ( ) var ( - content = []byte("pibigstar") + content = []byte("pibigstar") + content_16, _ = gbase64.Decode("v1jqsGHId/H8onlVHR8Vaw==") + content_24, _ = gbase64.Decode("0TXOaj5KMoLhNWmJ3lxY1A==") + content_32, _ = gbase64.Decode("qM/Waw1kkWhrwzek24rCSA==") + content_16_iv, _ = gbase64.Decode("DqQUXiHgW/XFb6Qs98+hrA==") // iv 长度必须等于blockSize，只能为16 iv = []byte("Hello My GoFrame") key_16 = []byte("1234567891234567") @@ -30,14 +35,18 @@ var ( func TestEncrypt(t *testing.T) { gtest.Case(t, func() { - _, err := gaes.Encrypt(content, key_16) + data, err := gaes.Encrypt(content, key_16) gtest.Assert(err, nil) - _, err = gaes.Encrypt(content, key_24) + gtest.Assert(string(data), content_16) + data, err = gaes.Encrypt(content, key_24) gtest.Assert(err, nil) - _, err = gaes.Encrypt(content, key_32) + gtest.Assert(string(data), content_24) + data, err = gaes.Encrypt(content, key_32) gtest.Assert(err, nil) - _, err = gaes.Encrypt(content, key_16, iv) + gtest.Assert(string(data), content_32) + data, err = gaes.Encrypt(content, key_16, iv) gtest.Assert(err, nil) + gtest.Assert(string(data), content_16_iv) }) } From b0b6871bbb581cc8b2e526b979a7f38f50da5a21 Mon Sep 17 00:00:00 2001 From: zdl <381897429@qq.com> Date: Mon, 10 Jun 2019 19:50:45 +0800 Subject: [PATCH 07/13] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20genv=20=E6=B5=8B?= =?UTF-8?q?=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- g/os/genv/genv_test.go | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 g/os/genv/genv_test.go diff --git a/g/os/genv/genv_test.go b/g/os/genv/genv_test.go new file mode 100644 index 000000000..e4b64062f --- /dev/null +++ b/g/os/genv/genv_test.go @@ -0,0 +1,36 @@ +package genv_test + +import ( + "github.com/gogf/gf/g/os/genv" + "github.com/gogf/gf/g/test/gtest" + "os" + "testing" + "time" +) + +func Test_Genv_All(t *testing.T) { + gtest.Case(t, func() { + gtest.Assert(os.Environ(), genv.All()) + }) +} + +func Test_Genv_Get(t *testing.T) { + gtest.Case(t, func() { + gtest.AssertEQ("keke", genv.Get("LLL"+time.Now().String(), "keke")) + gtest.AssertEQ("", genv.Get("LLL"+time.Now().String())) + }) +} + +func Test_Genv_Set(t *testing.T) { + gtest.Case(t, func() { + err := genv.Set("LLL", "keke") + gtest.Assert(err, nil) + }) +} + +func Test_Genv_Remove(t *testing.T) { + gtest.Case(t, func() { + err := genv.Remove("LLL") + gtest.Assert(err, nil) + }) +} From be6f522cf3c911a718948c185fe0453f4f8e0a52 Mon Sep 17 00:00:00 2001 From: zhangbiao Date: Mon, 10 Jun 2019 19:53:07 +0800 Subject: [PATCH 08/13] add gaes test4:optimize Encrypt Decrypt test --- g/crypto/gaes/gaes_test.go | 59 ++++++++++++++++++++------------------ 1 file changed, 31 insertions(+), 28 deletions(-) diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go index 36f0101a7..9805dda4a 100644 --- a/g/crypto/gaes/gaes_test.go +++ b/g/crypto/gaes/gaes_test.go @@ -22,6 +22,7 @@ var ( content_24, _ = gbase64.Decode("0TXOaj5KMoLhNWmJ3lxY1A==") content_32, _ = gbase64.Decode("qM/Waw1kkWhrwzek24rCSA==") content_16_iv, _ = gbase64.Decode("DqQUXiHgW/XFb6Qs98+hrA==") + content_32_iv, _ = gbase64.Decode("ZuLgAOii+lrD5KJoQ7yQ8Q==") // iv 长度必须等于blockSize，只能为16 iv = []byte("Hello My GoFrame") key_16 = []byte("1234567891234567") @@ -47,6 +48,36 @@ func TestEncrypt(t *testing.T) { data, err = gaes.Encrypt(content, key_16, iv) gtest.Assert(err, nil) gtest.Assert(string(data), content_16_iv) + data, err = gaes.Encrypt(content, key_32, iv) + gtest.Assert(err, nil) + gtest.Assert(string(data), content_32_iv) + }) +} + +func TestDecrypt(t *testing.T) { + gtest.Case(t, func() { + decrypt, err := gaes.Decrypt([]byte(content_16), key_16) + gtest.Assert(err, nil) + gtest.Assert(string(decrypt), string(content)) + + decrypt, err = gaes.Decrypt([]byte(content_24), key_24) + gtest.Assert(err, nil) + gtest.Assert(string(decrypt), string(content)) + + decrypt, err = gaes.Decrypt([]byte(content_32), key_32) + gtest.Assert(err, nil) + gtest.Assert(string(decrypt), string(content)) + + decrypt, err = gaes.Decrypt([]byte(content_16_iv), key_16, iv) + gtest.Assert(err, nil) + gtest.Assert(string(decrypt), string(content)) + + decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv) + gtest.Assert(err, nil) + gtest.Assert(string(decrypt), string(content)) + + decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv) + gtest.Assert(err, "invalid padding") }) } @@ -94,31 +125,3 @@ func TestPKCS5UnPaddingErr(t *testing.T) { gtest.AssertNE(err, nil) }) } - -func TestDecrypt(t *testing.T) { - gtest.Case(t, func() { - encrypt, err := gaes.Encrypt(content, key_16) - decrypt, err := gaes.Decrypt(encrypt, key_16) - gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) - - encrypt, err = gaes.Encrypt(content, key_24) - decrypt, err = gaes.Decrypt(encrypt, key_24) - gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) - - encrypt, err = gaes.Encrypt(content, key_32) - decrypt, err = gaes.Decrypt(encrypt, key_32) - gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) - - encrypt, err = gaes.Encrypt(content, key_32, iv) - decrypt, err = gaes.Decrypt(encrypt, key_32, iv) - gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) - - encrypt, err = gaes.Encrypt(content, key_32, iv) - decrypt, err = gaes.Decrypt(encrypt, keys, iv) - gtest.Assert(err, "invalid padding") - }) -} From e479c41667fceecfe486937ec0016dfa2154be7f Mon Sep 17 00:00:00 2001 From: zdl <381897429@qq.com> Date: Mon, 10 Jun 2019 20:24:11 +0800 Subject: [PATCH 09/13] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20genv=20=E6=B5=8B?= =?UTF-8?q?=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- g/os/genv/genv_test.go | 17 ++++++++++++----- go.mod | 4 +++- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/g/os/genv/genv_test.go b/g/os/genv/genv_test.go index e4b64062f..c67063d1c 100644 --- a/g/os/genv/genv_test.go +++ b/g/os/genv/genv_test.go @@ -5,7 +5,6 @@ import ( "github.com/gogf/gf/g/test/gtest" "os" "testing" - "time" ) func Test_Genv_All(t *testing.T) { @@ -16,21 +15,29 @@ func Test_Genv_All(t *testing.T) { func Test_Genv_Get(t *testing.T) { gtest.Case(t, func() { - gtest.AssertEQ("keke", genv.Get("LLL"+time.Now().String(), "keke")) - gtest.AssertEQ("", genv.Get("LLL"+time.Now().String())) + key := "TEST_ENV" + err := os.Setenv(key, "TEST") + gtest.Assert(err, nil) + gtest.AssertEQ(genv.Get(key), "TEST") }) } func Test_Genv_Set(t *testing.T) { gtest.Case(t, func() { - err := genv.Set("LLL", "keke") + key := "TEST_ENV" + err := genv.Set(key, "TEST") gtest.Assert(err, nil) + gtest.AssertEQ(os.Getenv(key), "TEST") }) } func Test_Genv_Remove(t *testing.T) { gtest.Case(t, func() { - err := genv.Remove("LLL") + key := "TEST_ENV" + err := os.Setenv(key, "TEST") gtest.Assert(err, nil) + err = genv.Remove(key) + gtest.Assert(err, nil) + gtest.AssertEQ(os.Getenv(key), "") }) } diff --git a/go.mod b/go.mod index fd3232e72..081d99cd0 100644 --- a/go.mod +++ b/go.mod @@ -1 +1,3 @@ -module github.com/gogf/gf \ No newline at end of file +module github.com/gogf/gf + +go 1.12 From ffd78d76e1d65040c3572aba37a7a428e65eae94 Mon Sep 17 00:00:00 2001 From: zdl <381897429@qq.com> Date: Mon, 10 Jun 2019 20:44:30 +0800 Subject: [PATCH 10/13] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20genv=20=E6=B5=8B?= =?UTF-8?q?=E8=AF=95=201?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- g/os/genv/genv_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/g/os/genv/genv_test.go b/g/os/genv/genv_test.go index c67063d1c..9f9a894e4 100644 --- a/g/os/genv/genv_test.go +++ b/g/os/genv/genv_test.go @@ -15,7 +15,7 @@ func Test_Genv_All(t *testing.T) { func Test_Genv_Get(t *testing.T) { gtest.Case(t, func() { - key := "TEST_ENV" + key := "TEST_GET_ENV" err := os.Setenv(key, "TEST") gtest.Assert(err, nil) gtest.AssertEQ(genv.Get(key), "TEST") @@ -24,7 +24,7 @@ func Test_Genv_Get(t *testing.T) { func Test_Genv_Set(t *testing.T) { gtest.Case(t, func() { - key := "TEST_ENV" + key := "TEST_SET_ENV" err := genv.Set(key, "TEST") gtest.Assert(err, nil) gtest.AssertEQ(os.Getenv(key), "TEST") @@ -33,7 +33,7 @@ func Test_Genv_Set(t *testing.T) { func Test_Genv_Remove(t *testing.T) { gtest.Case(t, func() { - key := "TEST_ENV" + key := "TEST_REMOVE_ENV" err := os.Setenv(key, "TEST") gtest.Assert(err, nil) err = genv.Remove(key) From c695dfd92e9a23e8be8eb58c009413d0b236d4de Mon Sep 17 00:00:00 2001 From: zdl <381897429@qq.com> Date: Mon, 10 Jun 2019 20:52:06 +0800 Subject: [PATCH 11/13] delete go version --- go.mod | 1 - 1 file changed, 1 deletion(-) diff --git a/go.mod b/go.mod index 081d99cd0..28729e4f6 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,2 @@ module github.com/gogf/gf -go 1.12 From 13eb1150a5d5c3c4d62607cd3c1d40ae288e4b32 Mon Sep 17 00:00:00 2001 From: John Date: Mon, 10 Jun 2019 21:32:40 +0800 Subject: [PATCH 12/13] fix issue in gfile.MainPkgPath --- g/os/gfile/gfile.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/g/os/gfile/gfile.go b/g/os/gfile/gfile.go index e55e156f4..e658a869b 100644 --- a/g/os/gfile/gfile.go +++ b/g/os/gfile/gfile.go @@ -425,8 +425,7 @@ func MainPkgPath() string { continue } // separator of '/' will be converted to Separator. - path = Dir(file) - for path[len(path) - 1] != os.PathSeparator { + for path = Dir(file); len(path) > 1 && Exists(path) && path[len(path) - 1] != os.PathSeparator; { files, _ := ScanDir(path, "*.go") for _, v := range files { if gregex.IsMatchString(`package\s+main`, GetContents(v)) { From 46d46afaafe3a513682a985633c2ddc7963222c6 Mon Sep 17 00:00:00 2001 From: "zcool321@sina.com" <1234qwer> Date: Mon, 10 Jun 2019 22:42:46 +0800 Subject: [PATCH 13/13] add gaes test:update assert type --- g/crypto/gaes/gaes_test.go | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go index 9805dda4a..57f307a6e 100644 --- a/g/crypto/gaes/gaes_test.go +++ b/g/crypto/gaes/gaes_test.go @@ -38,19 +38,19 @@ func TestEncrypt(t *testing.T) { gtest.Case(t, func() { data, err := gaes.Encrypt(content, key_16) gtest.Assert(err, nil) - gtest.Assert(string(data), content_16) + gtest.Assert(data, []byte(content_16)) data, err = gaes.Encrypt(content, key_24) gtest.Assert(err, nil) - gtest.Assert(string(data), content_24) + gtest.Assert(data, []byte(content_24)) data, err = gaes.Encrypt(content, key_32) gtest.Assert(err, nil) - gtest.Assert(string(data), content_32) + gtest.Assert(data, []byte(content_32)) data, err = gaes.Encrypt(content, key_16, iv) gtest.Assert(err, nil) - gtest.Assert(string(data), content_16_iv) + gtest.Assert(data, []byte(content_16_iv)) data, err = gaes.Encrypt(content, key_32, iv) gtest.Assert(err, nil) - gtest.Assert(string(data), content_32_iv) + gtest.Assert(data, []byte(content_32_iv)) }) } @@ -58,23 +58,23 @@ func TestDecrypt(t *testing.T) { gtest.Case(t, func() { decrypt, err := gaes.Decrypt([]byte(content_16), key_16) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_24), key_24) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_32), key_32) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_16_iv), key_16, iv) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv) gtest.Assert(err, "invalid padding")