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) + }) +} diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go index fbae75d9c..57f307a6e 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,52 +17,111 @@ 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==") + content_32_iv, _ = gbase64.Decode("ZuLgAOii+lrD5KJoQ7yQ8Q==") // 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) { 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(data, []byte(content_16)) + data, err = gaes.Encrypt(content, key_24) gtest.Assert(err, nil) - _, err = gaes.Encrypt(content, key_32) + gtest.Assert(data, []byte(content_24)) + data, err = gaes.Encrypt(content, key_32) gtest.Assert(err, nil) - _, err = gaes.Encrypt(content, key_16, iv) + gtest.Assert(data, []byte(content_32)) + data, err = gaes.Encrypt(content, key_16, iv) gtest.Assert(err, nil) + gtest.Assert(data, []byte(content_16_iv)) + data, err = gaes.Encrypt(content, key_32, iv) + gtest.Assert(err, nil) + gtest.Assert(data, []byte(content_32_iv)) }) } func TestDecrypt(t *testing.T) { gtest.Case(t, func() { - encrypt, err := gaes.Encrypt(content, key_16) - decrypt, err := gaes.Decrypt(encrypt, key_16) + decrypt, err := gaes.Decrypt([]byte(content_16), key_16) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) - encrypt, err = gaes.Encrypt(content, key_24) - decrypt, err = gaes.Decrypt(encrypt, key_24) + decrypt, err = gaes.Decrypt([]byte(content_24), key_24) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) - encrypt, err = gaes.Encrypt(content, key_32) - decrypt, err = gaes.Decrypt(encrypt, key_32) + decrypt, err = gaes.Decrypt([]byte(content_32), key_32) gtest.Assert(err, nil) - gtest.Assert(string(decrypt), string(content)) + gtest.Assert(decrypt, content) - encrypt, err = gaes.Encrypt(content, key_32, iv) - decrypt, err = gaes.Decrypt(encrypt, key_32, iv) + 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) - encrypt, err = gaes.Encrypt(content, key_32, iv) - decrypt, err = gaes.Decrypt(encrypt, keys, iv) + decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv) + gtest.Assert(err, nil) + gtest.Assert(decrypt, content) + + decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv) gtest.Assert(err, "invalid padding") }) } + +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) + }) +} diff --git a/g/crypto/gcrc32/gcrc32_test.go b/g/crypto/gcrc32/gcrc32_test.go index 32f9a3094..7a67d1c41 100644 --- a/g/crypto/gcrc32/gcrc32_test.go +++ b/g/crypto/gcrc32/gcrc32_test.go @@ -9,13 +9,14 @@ package gcrc32_test import ( + "github.com/gogf/gf/g/crypto/gmd5" "testing" "github.com/gogf/gf/g/crypto/gcrc32" "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 +26,19 @@ 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) + + strmd5 := gmd5.Encrypt(s) + test1 := gcrc32.Encrypt(strmd5) + test2 := gcrc32.Encrypt([]byte(strmd5)) + gtest.AssertEQ(test2, test1) + }) +} diff --git a/g/os/genv/genv_test.go b/g/os/genv/genv_test.go new file mode 100644 index 000000000..9f9a894e4 --- /dev/null +++ b/g/os/genv/genv_test.go @@ -0,0 +1,43 @@ +package genv_test + +import ( + "github.com/gogf/gf/g/os/genv" + "github.com/gogf/gf/g/test/gtest" + "os" + "testing" +) + +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() { + key := "TEST_GET_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() { + key := "TEST_SET_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() { + key := "TEST_REMOVE_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/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)) { 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) }) } diff --git a/go.mod b/go.mod index fd3232e72..28729e4f6 100644 --- a/go.mod +++ b/go.mod @@ -1 +1,2 @@ -module github.com/gogf/gf \ No newline at end of file +module github.com/gogf/gf +