From 57b8fac0d53968ccc5e5e5cb3bc29fa7ba219bc0 Mon Sep 17 00:00:00 2001 From: pibigstar Date: Fri, 5 Apr 2019 17:11:03 +0800 Subject: [PATCH 1/6] add the crypto test --- g/crypto/gaes/gaes_test.go | 62 +++++++++++++++++++++++++++++++++++ g/crypto/gcrc32/gcr32_test.go | 25 ++++++++++++++ g/crypto/gmd5/gmd5_test.go | 50 ++++++++++++++++++++++++++++ g/crypto/gsha1/gsha1_test.go | 55 +++++++++++++++++++++++++++++++ 4 files changed, 192 insertions(+) create mode 100644 g/crypto/gaes/gaes_test.go create mode 100644 g/crypto/gcrc32/gcr32_test.go create mode 100644 g/crypto/gmd5/gmd5_test.go create mode 100644 g/crypto/gsha1/gsha1_test.go diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go new file mode 100644 index 000000000..43f2b04c1 --- /dev/null +++ b/g/crypto/gaes/gaes_test.go @@ -0,0 +1,62 @@ +// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with this file, +// You can obtain one at https://github.com/gogf/gf. + +// go test *.go -bench=".*" + +package gaes_test + +import ( + "testing" + + "github.com/gogf/gf/g/crypto/gaes" + "github.com/gogf/gf/g/test/gtest" +) + +var ( + content = []byte("pibigstar") + // iv 长度必须等于blockSize，只能为16 + iv = []byte("Hello My GoFrame") + key_16 = []byte("1234567891234567") + key_24 = []byte("123456789123456789123456") + key_32 = []byte("12345678912345678912345678912345") +) + +func TestEncrypt(t *testing.T) { + gtest.Case(t, func() { + _, err := gaes.Encrypt(content, key_16) + gtest.Assert(err, nil) + _, err = gaes.Encrypt(content, key_24) + gtest.Assert(err, nil) + _, err = gaes.Encrypt(content, key_32) + gtest.Assert(err, nil) + _, err = gaes.Encrypt(content, key_16, iv) + gtest.Assert(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)) + }) +} diff --git a/g/crypto/gcrc32/gcr32_test.go b/g/crypto/gcrc32/gcr32_test.go new file mode 100644 index 000000000..73219d531 --- /dev/null +++ b/g/crypto/gcrc32/gcr32_test.go @@ -0,0 +1,25 @@ +// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with this file, +// You can obtain one at https://github.com/gogf/gf. + +// go test *.go -bench=".*" + +package gcrc32_test + +import ( + "testing" + + "github.com/gogf/gf/g/crypto/gcrc32" + "github.com/gogf/gf/g/test/gtest" +) + +func TestEncrypt(t *testing.T) { + gtest.Case(t, func() { + s := "pibigstar" + encrypt1 := gcrc32.EncryptString(s) + encrypt2 := gcrc32.EncryptBytes([]byte(s)) + gtest.AssertEQ(encrypt1, encrypt2) + }) +} diff --git a/g/crypto/gmd5/gmd5_test.go b/g/crypto/gmd5/gmd5_test.go new file mode 100644 index 000000000..eaff5a2b1 --- /dev/null +++ b/g/crypto/gmd5/gmd5_test.go @@ -0,0 +1,50 @@ +// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with this file, +// You can obtain one at https://github.com/gogf/gf. + +// go test *.go -bench=".*" + +package gmd5_test + +import ( + "os" + "testing" + + "github.com/gogf/gf/g/crypto/gmd5" + "github.com/gogf/gf/g/test/gtest" +) + +var ( + s = "pibigstar" + // 根据在线工具生成的md5值 + result = "d175a1ff66aedde64344785f7f7a3df8" +) + +func TestEncrypt(t *testing.T) { + gtest.Case(t, func() { + encryptString := gmd5.Encrypt(s) + gtest.Assert(encryptString, result) + }) +} + +func TestEncryptString(t *testing.T) { + gtest.Case(t, func() { + encryptString := gmd5.EncryptString(s) + gtest.Assert(encryptString, result) + }) +} + +func TestEncryptFile(t *testing.T) { + path := "test.text" + gtest.Case(t, func() { + file, err := os.Create(path) + gtest.Assert(err, nil) + defer file.Close() + file.Write([]byte("Hello Go Frame")) + encryptFile := gmd5.EncryptFile(path) + gtest.AssertNE(encryptFile, "") + }) + os.Remove(path) +} diff --git a/g/crypto/gsha1/gsha1_test.go b/g/crypto/gsha1/gsha1_test.go new file mode 100644 index 000000000..d53ae5265 --- /dev/null +++ b/g/crypto/gsha1/gsha1_test.go @@ -0,0 +1,55 @@ +// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with this file, +// You can obtain one at https://github.com/gogf/gf. + +// go test *.go -bench=".*" + +package gsha1_test + +import ( + "os" + "testing" + + "github.com/gogf/gf/g/crypto/gsha1" + "github.com/gogf/gf/g/test/gtest" +) + +type user struct { + name string + password string + age int +} + +func TestEncrypt(t *testing.T) { + gtest.Case(t, func() { + user := &user{ + name: "派大星", + password: "123456", + age: 23, + } + encrypt := gsha1.Encrypt(user) + gtest.AssertNE(encrypt, "") + }) +} + +func TestEncryptString(t *testing.T) { + gtest.Case(t, func() { + s := gsha1.EncryptString("pibigstar") + gtest.AssertNE(s, "") + }) +} + +func TestEncryptFile(t *testing.T) { + path := "test.text" + gtest.Case(t, func() { + file, err := os.Create(path) + gtest.Assert(err, nil) + defer file.Close() + file.Write([]byte("Hello Go Frame")) + encryptFile := gsha1.EncryptFile(path) + gtest.AssertNE(encryptFile, "") + }) + os.Remove(path) +} From 145b52f34302a7d2d12e3113d88beb55a0f5c36a Mon Sep 17 00:00:00 2001 From: pibigstar Date: Sat, 6 Apr 2019 12:18:51 +0800 Subject: [PATCH 2/6] increase coverage for crypto #66 --- .../gcrc32/{gcr32_test.go => gcrc32_test.go} | 0 g/crypto/gmd5/gmd5_test.go | 21 ++++++++++++++++++- g/crypto/gsha1/gsha1_test.go | 6 +++++- 3 files changed, 25 insertions(+), 2 deletions(-) rename g/crypto/gcrc32/{gcr32_test.go => gcrc32_test.go} (100%) diff --git a/g/crypto/gcrc32/gcr32_test.go b/g/crypto/gcrc32/gcrc32_test.go similarity index 100% rename from g/crypto/gcrc32/gcr32_test.go rename to g/crypto/gcrc32/gcrc32_test.go diff --git a/g/crypto/gmd5/gmd5_test.go b/g/crypto/gmd5/gmd5_test.go index eaff5a2b1..7d40626f3 100644 --- a/g/crypto/gmd5/gmd5_test.go +++ b/g/crypto/gmd5/gmd5_test.go @@ -22,10 +22,29 @@ var ( result = "d175a1ff66aedde64344785f7f7a3df8" ) +type user struct { + name string + password string + age int +} + func TestEncrypt(t *testing.T) { gtest.Case(t, func() { encryptString := gmd5.Encrypt(s) gtest.Assert(encryptString, result) + + encrypt := gmd5.Encrypt(123456) + gtest.AssertNE(encrypt,"") + }) + + gtest.Case(t, func() { + user := &user{ + name: "派大星", + password: "123456", + age: 23, + } + encrypt := gmd5.Encrypt(user) + gtest.AssertNE(encrypt,"") }) } @@ -46,5 +65,5 @@ func TestEncryptFile(t *testing.T) { encryptFile := gmd5.EncryptFile(path) gtest.AssertNE(encryptFile, "") }) - os.Remove(path) + defer os.Remove(path) } diff --git a/g/crypto/gsha1/gsha1_test.go b/g/crypto/gsha1/gsha1_test.go index d53ae5265..bff462482 100644 --- a/g/crypto/gsha1/gsha1_test.go +++ b/g/crypto/gsha1/gsha1_test.go @@ -32,6 +32,10 @@ func TestEncrypt(t *testing.T) { encrypt := gsha1.Encrypt(user) gtest.AssertNE(encrypt, "") }) + gtest.Case(t, func() { + s := gsha1.Encrypt("pibigstar") + gtest.AssertNE(s, "") + }) } func TestEncryptString(t *testing.T) { @@ -51,5 +55,5 @@ func TestEncryptFile(t *testing.T) { encryptFile := gsha1.EncryptFile(path) gtest.AssertNE(encryptFile, "") }) - os.Remove(path) + defer os.Remove(path) } From ae552e2b466ac602874fce6a973eb1a88b68452a Mon Sep 17 00:00:00 2001 From: pibigstar Date: Sat, 6 Apr 2019 15:06:42 +0800 Subject: [PATCH 3/6] increase coverage for crypto #66 --- g/crypto/gdes/gdes_test.go | 65 ++++++++++++++++++++++++++---------- g/crypto/gmd5/gmd5_test.go | 5 +++ g/crypto/gsha1/gsha1_test.go | 3 ++ 3 files changed, 55 insertions(+), 18 deletions(-) diff --git a/g/crypto/gdes/gdes_test.go b/g/crypto/gdes/gdes_test.go index 075e7d07b..c19153ed1 100644 --- a/g/crypto/gdes/gdes_test.go +++ b/g/crypto/gdes/gdes_test.go @@ -1,6 +1,7 @@ package gdes_test import ( + "github.com/gogf/gf/g/test/gtest" "testing" "bytes" "encoding/hex" @@ -8,8 +9,14 @@ import ( "github.com/gogf/gf/g/crypto/gdes" ) +var( + errKey = []byte("1111111111111234123456789") + errIv = []byte("12345678") + errPadding = 5 +) + func TestDesECB(t *testing.T){ - { + gtest.Case(t, func() { key := []byte("11111111") text := []byte("12345678") padding := gdes.NOPADDING @@ -17,7 +24,7 @@ func TestDesECB(t *testing.T){ if err != nil { t.Errorf("%v", err) } - + clearText, err := gdes.DesECBDecrypt(key, cipherText, padding) if err != nil { t.Errorf("%v", err) @@ -28,12 +35,16 @@ func TestDesECB(t *testing.T){ } fmt.Println("clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - } + // err test + gdes.DesECBEncrypt(key, text, errPadding) + gdes.DesECBDecrypt(errKey, cipherText, padding) + }) - { + gtest.Case(t, func() { key := []byte("11111111") text := []byte("12345678") padding := gdes.PKCS5PADDING + errPadding := 5 cipherText, err := gdes.DesECBEncrypt(key, text, padding) if err != nil { t.Errorf("%v", err) @@ -48,7 +59,11 @@ func TestDesECB(t *testing.T){ t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) } fmt.Println("clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - } + + // err test + gdes.DesECBEncrypt(key, text, errPadding) + gdes.DesECBDecrypt(errKey, cipherText, padding) + }) } func Test3DesECB(t *testing.T){ @@ -70,13 +85,15 @@ func Test3DesECB(t *testing.T){ t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) } fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - + // err test + gdes.DesECBEncrypt(key, text, errPadding) } - { + gtest.Case(t, func() { key := []byte("111111111111123412345678") text := []byte("123456789") padding := gdes.PKCS5PADDING + errPadding := 5 cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding) if err != nil { t.Errorf("%v", err) @@ -91,11 +108,16 @@ func Test3DesECB(t *testing.T){ t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) } fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - } + // err test + gdes.TripleDesECBEncrypt(errKey, text, padding) + gdes.TripleDesECBEncrypt(key, text, errPadding) + + gdes.TripleDesECBDecrypt(errKey, text, padding) + }) } func TestDesCBC(t *testing.T){ - { + gtest.Case(t, func() { key := []byte("11111111") text := []byte("1234567812345678") padding := gdes.NOPADDING @@ -114,10 +136,12 @@ func TestDesCBC(t *testing.T){ t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) } fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) + // err test + gdes.DesCBCEncrypt(errKey, text, iv,padding) + gdes.DesCBCEncrypt(errKey, text, iv,errPadding) + }) - } - - { + gtest.Case(t, func() { key := []byte("11111111") text := []byte("12345678") padding := gdes.PKCS5PADDING @@ -136,11 +160,15 @@ func TestDesCBC(t *testing.T){ t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) } fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - } + + // err test + gdes.DesCBCEncrypt(key, text, errIv, padding) + gdes.DesCBCEncrypt(key, text, errIv, padding) + }) } func Test3DesCBC(t *testing.T){ - { + gtest.Case(t, func() { key := []byte("1111111112345678") text := []byte("1234567812345678") padding := gdes.NOPADDING @@ -160,9 +188,9 @@ func Test3DesCBC(t *testing.T){ } fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - } - - { + gdes.TripleDesCBCEncrypt(errKey, text, iv,padding) + }) + gtest.Case(t, func() { key := []byte("111111111234567812345678") text := []byte("12345678") padding := gdes.PKCS5PADDING @@ -181,5 +209,6 @@ func Test3DesCBC(t *testing.T){ t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) } fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - } + }) + } \ No newline at end of file diff --git a/g/crypto/gmd5/gmd5_test.go b/g/crypto/gmd5/gmd5_test.go index 7d40626f3..ebc43a498 100644 --- a/g/crypto/gmd5/gmd5_test.go +++ b/g/crypto/gmd5/gmd5_test.go @@ -57,6 +57,7 @@ func TestEncryptString(t *testing.T) { func TestEncryptFile(t *testing.T) { path := "test.text" + errorPath := "err.txt" gtest.Case(t, func() { file, err := os.Create(path) gtest.Assert(err, nil) @@ -64,6 +65,10 @@ func TestEncryptFile(t *testing.T) { file.Write([]byte("Hello Go Frame")) encryptFile := gmd5.EncryptFile(path) gtest.AssertNE(encryptFile, "") + + errEncrypt := gmd5.EncryptFile(errorPath) + gtest.AssertEQ(errEncrypt, "") }) + defer os.Remove(path) } diff --git a/g/crypto/gsha1/gsha1_test.go b/g/crypto/gsha1/gsha1_test.go index bff462482..3593b09a9 100644 --- a/g/crypto/gsha1/gsha1_test.go +++ b/g/crypto/gsha1/gsha1_test.go @@ -47,6 +47,7 @@ func TestEncryptString(t *testing.T) { func TestEncryptFile(t *testing.T) { path := "test.text" + errPath := "err.text" gtest.Case(t, func() { file, err := os.Create(path) gtest.Assert(err, nil) @@ -54,6 +55,8 @@ func TestEncryptFile(t *testing.T) { file.Write([]byte("Hello Go Frame")) encryptFile := gsha1.EncryptFile(path) gtest.AssertNE(encryptFile, "") + errEncrypt := gsha1.EncryptFile(errPath) + gtest.AssertEQ(errEncrypt,"") }) defer os.Remove(path) } From 60e7ab95bcf38281e283a2f2b056a124c93b083b Mon Sep 17 00:00:00 2001 From: pibigstar Date: Sat, 6 Apr 2019 15:24:41 +0800 Subject: [PATCH 4/6] increase coverage for crypto #66 --- g/crypto/gdes/gdes_test.go | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/g/crypto/gdes/gdes_test.go b/g/crypto/gdes/gdes_test.go index c19153ed1..31f918c70 100644 --- a/g/crypto/gdes/gdes_test.go +++ b/g/crypto/gdes/gdes_test.go @@ -37,7 +37,10 @@ func TestDesECB(t *testing.T){ // err test gdes.DesECBEncrypt(key, text, errPadding) + gdes.DesECBEncrypt(errKey, text, padding) + gdes.DesECBDecrypt(errKey, cipherText, padding) + gdes.DesECBDecrypt(key, cipherText, errPadding) }) gtest.Case(t, func() { @@ -138,7 +141,12 @@ func TestDesCBC(t *testing.T){ fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) // err test gdes.DesCBCEncrypt(errKey, text, iv,padding) - gdes.DesCBCEncrypt(errKey, text, iv,errPadding) + gdes.DesCBCEncrypt(key, text, errIv,padding) + gdes.DesCBCEncrypt(key, text, iv,errPadding) + + gdes.DesCBCDecrypt(errKey, cipherText, iv, padding) + gdes.DesCBCDecrypt(key, cipherText, errIv, padding) + gdes.DesCBCDecrypt(key, cipherText, iv, errPadding) }) gtest.Case(t, func() { @@ -187,8 +195,14 @@ func Test3DesCBC(t *testing.T){ t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) } fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - + // err test gdes.TripleDesCBCEncrypt(errKey, text, iv,padding) + gdes.TripleDesCBCEncrypt(key, text, errIv,padding) + gdes.TripleDesCBCEncrypt(key, text, iv,errPadding) + + gdes.TripleDesCBCDecrypt(errKey, cipherText, iv, padding) + gdes.TripleDesCBCDecrypt(key, cipherText, errIv, padding) + gdes.TripleDesCBCDecrypt(key, cipherText, iv, errPadding) }) gtest.Case(t, func() { key := []byte("111111111234567812345678") From 53e9f05a10bf337fa2d4309994d3738563c24716 Mon Sep 17 00:00:00 2001 From: pibigstar Date: Mon, 8 Apr 2019 11:53:29 +0800 Subject: [PATCH 5/6] make the details perfect #66 --- g/crypto/gcrc32/gcrc32_test.go | 4 +++- g/crypto/gmd5/gmd5_test.go | 5 +++-- g/crypto/gsha1/gsha1_test.go | 4 ++-- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/g/crypto/gcrc32/gcrc32_test.go b/g/crypto/gcrc32/gcrc32_test.go index 73219d531..32f9a3094 100644 --- a/g/crypto/gcrc32/gcrc32_test.go +++ b/g/crypto/gcrc32/gcrc32_test.go @@ -18,8 +18,10 @@ import ( func TestEncrypt(t *testing.T) { gtest.Case(t, func() { s := "pibigstar" + result := 693191136 encrypt1 := gcrc32.EncryptString(s) encrypt2 := gcrc32.EncryptBytes([]byte(s)) - gtest.AssertEQ(encrypt1, encrypt2) + gtest.AssertEQ(int(encrypt1), result) + gtest.AssertEQ(int(encrypt2), result) }) } diff --git a/g/crypto/gmd5/gmd5_test.go b/g/crypto/gmd5/gmd5_test.go index ebc43a498..91b767409 100644 --- a/g/crypto/gmd5/gmd5_test.go +++ b/g/crypto/gmd5/gmd5_test.go @@ -60,8 +60,9 @@ func TestEncryptFile(t *testing.T) { errorPath := "err.txt" gtest.Case(t, func() { file, err := os.Create(path) - gtest.Assert(err, nil) + defer os.Remove(path) defer file.Close() + gtest.Assert(err, nil) file.Write([]byte("Hello Go Frame")) encryptFile := gmd5.EncryptFile(path) gtest.AssertNE(encryptFile, "") @@ -70,5 +71,5 @@ func TestEncryptFile(t *testing.T) { gtest.AssertEQ(errEncrypt, "") }) - defer os.Remove(path) + } diff --git a/g/crypto/gsha1/gsha1_test.go b/g/crypto/gsha1/gsha1_test.go index 3593b09a9..042318210 100644 --- a/g/crypto/gsha1/gsha1_test.go +++ b/g/crypto/gsha1/gsha1_test.go @@ -50,13 +50,13 @@ func TestEncryptFile(t *testing.T) { errPath := "err.text" gtest.Case(t, func() { file, err := os.Create(path) - gtest.Assert(err, nil) + defer os.Remove(path) defer file.Close() + gtest.Assert(err, nil) file.Write([]byte("Hello Go Frame")) encryptFile := gsha1.EncryptFile(path) gtest.AssertNE(encryptFile, "") errEncrypt := gsha1.EncryptFile(errPath) gtest.AssertEQ(errEncrypt,"") }) - defer os.Remove(path) } From d12532ccc120226369b35b659b6719eb37c7fa53 Mon Sep 17 00:00:00 2001 From: pibigstar Date: Fri, 12 Apr 2019 23:29:31 +0800 Subject: [PATCH 6/6] set a definite value for an assertion #66 --- g/crypto/gdes/gdes_test.go | 301 ++++++++++++++++++----------------- g/crypto/gmd5/gmd5_test.go | 13 +- g/crypto/gsha1/gsha1_test.go | 13 +- 3 files changed, 173 insertions(+), 154 deletions(-) diff --git a/g/crypto/gdes/gdes_test.go b/g/crypto/gdes/gdes_test.go index 31f918c70..bba03375f 100644 --- a/g/crypto/gdes/gdes_test.go +++ b/g/crypto/gdes/gdes_test.go @@ -1,46 +1,48 @@ package gdes_test import ( - "github.com/gogf/gf/g/test/gtest" - "testing" - "bytes" "encoding/hex" - "fmt" + "testing" + "github.com/gogf/gf/g/crypto/gdes" + "github.com/gogf/gf/g/test/gtest" ) -var( - errKey = []byte("1111111111111234123456789") - errIv = []byte("12345678") +var ( + errKey = []byte("1111111111111234123456789") + errIv = []byte("123456789") errPadding = 5 ) -func TestDesECB(t *testing.T){ +func TestDesECB(t *testing.T) { gtest.Case(t, func() { key := []byte("11111111") text := []byte("12345678") padding := gdes.NOPADDING + result := "858b176da8b12503" + // encrypt test cipherText, err := gdes.DesECBEncrypt(key, text, padding) - if err != nil { - t.Errorf("%v", err) - } - + gtest.AssertEQ(err, nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.DesECBDecrypt(key, cipherText, padding) - if err != nil { - t.Errorf("%v", err) - } + gtest.AssertEQ(err, nil) + gtest.AssertEQ(string(clearText), "12345678") - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - - // err test - gdes.DesECBEncrypt(key, text, errPadding) - gdes.DesECBEncrypt(errKey, text, padding) - - gdes.DesECBDecrypt(errKey, cipherText, padding) - gdes.DesECBDecrypt(key, cipherText, errPadding) + // encrypt err test. when throw exception,the err is not equal nil and the string is nil + errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + errEncrypt, err = gdes.DesECBEncrypt(errKey, text, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // err decrypt test. + errDecrypt, err := gdes.DesECBDecrypt(errKey, cipherText, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) + errDecrypt, err = gdes.DesECBDecrypt(key, cipherText, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) }) gtest.Case(t, func() { @@ -48,105 +50,113 @@ func TestDesECB(t *testing.T){ text := []byte("12345678") padding := gdes.PKCS5PADDING errPadding := 5 + result := "858b176da8b12503ad6a88b4fa37833d" cipherText, err := gdes.DesECBEncrypt(key, text, padding) - if err != nil { - t.Errorf("%v", err) - } - + gtest.AssertEQ(err,nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.DesECBDecrypt(key, cipherText, padding) - if err != nil { - t.Errorf("%v", err) - } - - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(string(clearText),"12345678") // err test - gdes.DesECBEncrypt(key, text, errPadding) - gdes.DesECBDecrypt(errKey, cipherText, padding) + errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + errDecrypt, err := gdes.DesECBDecrypt(errKey, cipherText, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) }) } -func Test3DesECB(t *testing.T){ - { +func Test3DesECB(t *testing.T) { + gtest.Case(t, func() { key := []byte("1111111111111234") text := []byte("1234567812345678") padding := gdes.NOPADDING + result := "a23ee24b98c26263a23ee24b98c26263" + // encrypt test cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding) - if err != nil { - t.Errorf("%v", err) - } - + gtest.AssertEQ(err,nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding) - if err != nil { - t.Errorf("%v", err) - } - - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(string(clearText),"1234567812345678") // err test - gdes.DesECBEncrypt(key, text, errPadding) - } + errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + }) gtest.Case(t, func() { key := []byte("111111111111123412345678") text := []byte("123456789") padding := gdes.PKCS5PADDING errPadding := 5 + result := "37989b1effc07a6d00ff89a7d052e79f" + // encrypt test cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding) - if err != nil { - t.Errorf("%v", err) - } - + gtest.AssertEQ(err,nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding) - if err != nil { - t.Errorf("%v", err) - } - - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - // err test - gdes.TripleDesECBEncrypt(errKey, text, padding) - gdes.TripleDesECBEncrypt(key, text, errPadding) - - gdes.TripleDesECBDecrypt(errKey, text, padding) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(string(clearText),"123456789") + // err test, when key is err, but text and padding is right + errEncrypt, err := gdes.TripleDesECBEncrypt(errKey, text, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // when padding is err,but key and text is right + errEncrypt, err = gdes.TripleDesECBEncrypt(key, text, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // decrypt err test,when key is err + errEncrypt, err = gdes.TripleDesECBDecrypt(errKey, text, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) }) } -func TestDesCBC(t *testing.T){ +func TestDesCBC(t *testing.T) { gtest.Case(t, func() { key := []byte("11111111") text := []byte("1234567812345678") padding := gdes.NOPADDING iv := []byte("12345678") - cipherText, err := gdes.DesCBCEncrypt(key, text, iv,padding) - if err != nil { - t.Errorf("%v", err) - } - + result := "40826a5800608c87585ca7c9efabee47" + // encrypt test + cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding) - if err != nil { - t.Errorf("%v", err) - } - - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - // err test - gdes.DesCBCEncrypt(errKey, text, iv,padding) - gdes.DesCBCEncrypt(key, text, errIv,padding) - gdes.DesCBCEncrypt(key, text, iv,errPadding) - - gdes.DesCBCDecrypt(errKey, cipherText, iv, padding) - gdes.DesCBCDecrypt(key, cipherText, errIv, padding) - gdes.DesCBCDecrypt(key, cipherText, iv, errPadding) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(string(clearText),"1234567812345678") + // encrypt err test. + errEncrypt, err := gdes.DesCBCEncrypt(errKey, text, iv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // the iv is err + errEncrypt, err = gdes.DesCBCEncrypt(key, text, errIv, padding) + //gtest.AssertNE(err,nil) + gtest.AssertEQ(errEncrypt, nil) + // the padding is err + errEncrypt, err = gdes.DesCBCEncrypt(key, text, iv, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // decrypt err test. the key is err + errDecrypt, err := gdes.DesCBCDecrypt(errKey, cipherText, iv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) + // the iv is err + errDecrypt, err = gdes.DesCBCDecrypt(key, cipherText, errIv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) + // the padding is err + errDecrypt, err = gdes.DesCBCDecrypt(key, cipherText, iv, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) }) gtest.Case(t, func() { @@ -154,75 +164,76 @@ func TestDesCBC(t *testing.T){ text := []byte("12345678") padding := gdes.PKCS5PADDING iv := []byte("12345678") + result := "40826a5800608c87100a25d86ac7c52c" + // encrypt test cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding) - if err != nil { - t.Errorf("%v", err) - } - + gtest.AssertEQ(err,nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding) - if err != nil { - t.Errorf("%v", err) - } - - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - + gtest.AssertEQ(err,nil) + gtest.AssertEQ(string(clearText),"12345678") // err test - gdes.DesCBCEncrypt(key, text, errIv, padding) - gdes.DesCBCEncrypt(key, text, errIv, padding) + errEncrypt, err := gdes.DesCBCEncrypt(key, text, errIv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) }) } -func Test3DesCBC(t *testing.T){ +func Test3DesCBC(t *testing.T) { gtest.Case(t, func() { key := []byte("1111111112345678") text := []byte("1234567812345678") padding := gdes.NOPADDING iv := []byte("12345678") - cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv,padding) - if err != nil { - t.Errorf("%v", err) - } - + result := "bfde1394e265d5f738d5cab170c77c88" + // encrypt test + cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding) - if err != nil { - t.Errorf("%v", err) - } - - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) - // err test - gdes.TripleDesCBCEncrypt(errKey, text, iv,padding) - gdes.TripleDesCBCEncrypt(key, text, errIv,padding) - gdes.TripleDesCBCEncrypt(key, text, iv,errPadding) - - gdes.TripleDesCBCDecrypt(errKey, cipherText, iv, padding) - gdes.TripleDesCBCDecrypt(key, cipherText, errIv, padding) - gdes.TripleDesCBCDecrypt(key, cipherText, iv, errPadding) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(string(clearText),"1234567812345678") + // encrypt err test + errEncrypt, err := gdes.TripleDesCBCEncrypt(errKey, text, iv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // the iv is err + errEncrypt, err = gdes.TripleDesCBCEncrypt(key, text, errIv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // the padding is err + errEncrypt, err = gdes.TripleDesCBCEncrypt(key, text, iv, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errEncrypt, nil) + // decrypt err test + errDecrypt, err := gdes.TripleDesCBCDecrypt(errKey, cipherText, iv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) + // the iv is err + errDecrypt, err = gdes.TripleDesCBCDecrypt(key, cipherText, errIv, padding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) + // the padding is err + errDecrypt, err = gdes.TripleDesCBCDecrypt(key, cipherText, iv, errPadding) + gtest.AssertNE(err, nil) + gtest.AssertEQ(errDecrypt, nil) }) gtest.Case(t, func() { key := []byte("111111111234567812345678") text := []byte("12345678") padding := gdes.PKCS5PADDING iv := []byte("12345678") + result := "40826a5800608c87100a25d86ac7c52c" + // encrypt test cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding) - if err != nil { - t.Errorf("%v", err) - } - + gtest.AssertEQ(err,nil) + gtest.AssertEQ(hex.EncodeToString(cipherText),result) + // decrypt test clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding) - if err != nil { - t.Errorf("%v", err) - } - - if bytes.Equal(clearText, text) == false { - t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText)) - } - fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText)) + gtest.AssertEQ(err,nil) + gtest.AssertEQ(string(clearText),"12345678") }) -} \ No newline at end of file +} diff --git a/g/crypto/gmd5/gmd5_test.go b/g/crypto/gmd5/gmd5_test.go index 91b767409..12c3f066e 100644 --- a/g/crypto/gmd5/gmd5_test.go +++ b/g/crypto/gmd5/gmd5_test.go @@ -18,7 +18,7 @@ import ( var ( s = "pibigstar" - // 根据在线工具生成的md5值 + // online generated MD5 value result = "d175a1ff66aedde64344785f7f7a3df8" ) @@ -33,8 +33,9 @@ func TestEncrypt(t *testing.T) { encryptString := gmd5.Encrypt(s) gtest.Assert(encryptString, result) + result := "1427562bb29f88a1161590b76398ab72" encrypt := gmd5.Encrypt(123456) - gtest.AssertNE(encrypt,"") + gtest.AssertEQ(encrypt,result) }) gtest.Case(t, func() { @@ -43,8 +44,9 @@ func TestEncrypt(t *testing.T) { password: "123456", age: 23, } + result := "70917ebce8bd2f78c736cda63870fb39" encrypt := gmd5.Encrypt(user) - gtest.AssertNE(encrypt,"") + gtest.AssertEQ(encrypt,result) }) } @@ -58,6 +60,7 @@ func TestEncryptString(t *testing.T) { func TestEncryptFile(t *testing.T) { path := "test.text" errorPath := "err.txt" + result := "e6e6e1cd41895beebff16d5452dfce12" gtest.Case(t, func() { file, err := os.Create(path) defer os.Remove(path) @@ -65,8 +68,8 @@ func TestEncryptFile(t *testing.T) { gtest.Assert(err, nil) file.Write([]byte("Hello Go Frame")) encryptFile := gmd5.EncryptFile(path) - gtest.AssertNE(encryptFile, "") - + gtest.AssertEQ(encryptFile, result) + // when the file is not exist,encrypt will return empty string errEncrypt := gmd5.EncryptFile(errorPath) gtest.AssertEQ(errEncrypt, "") }) diff --git a/g/crypto/gsha1/gsha1_test.go b/g/crypto/gsha1/gsha1_test.go index 042318210..59f21489c 100644 --- a/g/crypto/gsha1/gsha1_test.go +++ b/g/crypto/gsha1/gsha1_test.go @@ -29,19 +29,22 @@ func TestEncrypt(t *testing.T) { password: "123456", age: 23, } + result := "97386736e3ee4adee5ca595c78c12129f6032cad" encrypt := gsha1.Encrypt(user) - gtest.AssertNE(encrypt, "") + gtest.AssertEQ(encrypt, result) }) gtest.Case(t, func() { + result := "5b4c1c2a08ca85ddd031ef8627414f4cb2620b41" s := gsha1.Encrypt("pibigstar") - gtest.AssertNE(s, "") + gtest.AssertEQ(s, result) }) } func TestEncryptString(t *testing.T) { gtest.Case(t, func() { + result := "5b4c1c2a08ca85ddd031ef8627414f4cb2620b41" s := gsha1.EncryptString("pibigstar") - gtest.AssertNE(s, "") + gtest.AssertEQ(s, result) }) } @@ -49,13 +52,15 @@ func TestEncryptFile(t *testing.T) { path := "test.text" errPath := "err.text" gtest.Case(t, func() { + result := "8b05d3ba24b8d2374b8f5149d9f3fbada14ea984" file, err := os.Create(path) defer os.Remove(path) defer file.Close() gtest.Assert(err, nil) file.Write([]byte("Hello Go Frame")) encryptFile := gsha1.EncryptFile(path) - gtest.AssertNE(encryptFile, "") + gtest.AssertEQ(encryptFile, result) + // when the file is not exist,encrypt will return empty string errEncrypt := gsha1.EncryptFile(errPath) gtest.AssertEQ(errEncrypt,"") })