diff --git a/3des_test.go b/3des_test.go
index b42df2c..54b8cad 100644
--- a/3des_test.go
+++ b/3des_test.go
@@ -50,7 +50,7 @@ var tripleDesTests = []struct {
 	{ECB, PKCS7, "hello world", "b8097975c76319c6172687e0d90fd4d1", "XAEXS5OHMMM4MFZGQ7QNSD6U2E======", "uAl5dcdjGcYXJofg2Q/U0Q=="},
 }
 
-func Test3Des_Encrypt_ToString(t *testing.T) {
+func Test3Des_Encrypt_String(t *testing.T) {
 	for index, test := range tripleDesTests {
 		raw := Decode.FromString(test.toHex).ByHex().ToString()
 		e := Encrypt.FromString(test.input).By3Des(getCipher(test.mode, test.padding, tripleDesKey, tripleDesIV))
@@ -70,7 +70,7 @@ func Test3Des_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func Test3Des_Decrypt_ToString(t *testing.T) {
+func Test3Des_Decrypt_String(t *testing.T) {
 	for index, test := range tripleDesTests {
 		raw := Decode.FromString(test.toHex).ByHex().ToString()
 		e := Decrypt.FromRawString(raw).By3Des(getCipher(test.mode, test.padding, tripleDesKey, tripleDesIV))
@@ -103,7 +103,7 @@ func Test3Des_Decrypt_ToString(t *testing.T) {
 	}
 }
 
-func Test3Des_Encrypt_ToBytes(t *testing.T) {
+func Test3Des_Encrypt_Bytes(t *testing.T) {
 	for index, test := range tripleDesTests {
 		raw := Decode.FromBytes([]byte(test.toHex)).ByHex().ToBytes()
 		e := Encrypt.FromBytes([]byte(test.input)).By3Des(getCipher(test.mode, test.padding, []byte(tripleDesKey), []byte(tripleDesIV)))
@@ -123,7 +123,7 @@ func Test3Des_Encrypt_ToBytes(t *testing.T) {
 	}
 }
 
-func Test3Des_Decrypt_ToBytes(t *testing.T) {
+func Test3Des_Decrypt_Bytes(t *testing.T) {
 	for index, test := range tripleDesTests {
 		raw := Decode.FromBytes([]byte(test.toHex)).ByHex().ToBytes()
 		e := Decrypt.FromRawBytes(raw).By3Des(getCipher(test.mode, test.padding, []byte(tripleDesKey), []byte(tripleDesIV)))
diff --git a/baseX_test.go b/baseX_test.go
index 778b945..93f130f 100644
--- a/baseX_test.go
+++ b/baseX_test.go
@@ -56,42 +56,58 @@ var baseXTests = []struct {
 	{"base100", "hello world", "👟👜👣👣👦🐗👮👦👩👣👛"},
 }
 
-func TestBaseX_Encode_ToString(t *testing.T) {
+func TestBaseX_Encode_String(t *testing.T) {
 	for index, test := range baseXTests {
-		e := Encode.FromString(test.input)
+		e1 := Encode.FromString(test.input)
+		e2 := Encode.FromBytes([]byte(test.input))
 
 		switch test.baseX {
 		case "hex":
-			e = e.ByHex()
+			e1 = e1.ByHex()
+			e2 = e2.ByHex()
 		case "base16":
-			e = e.ByBase16()
+			e1 = e1.ByBase16()
+			e2 = e2.ByBase16()
 		case "base32":
-			e = e.ByBase32()
+			e1 = e1.ByBase32()
+			e2 = e2.ByBase32()
 		case "base58":
-			e = e.ByBase58()
+			e1 = e1.ByBase58()
+			e2 = e2.ByBase58()
 		case "base62":
-			e = e.ByBase62()
+			e1 = e1.ByBase62()
+			e2 = e2.ByBase62()
 		case "base64":
-			e = e.ByBase64()
+			e1 = e1.ByBase64()
+			e2 = e2.ByBase64()
 		case "base64URL":
-			e = e.ByBase64URL()
+			e1 = e1.ByBase64URL()
+			e2 = e2.ByBase64URL()
 		case "base85":
-			e = e.ByBase85()
+			e1 = e1.ByBase85()
+			e2 = e2.ByBase85()
 		case "base91":
-			e = e.ByBase91()
+			e1 = e1.ByBase91()
+			e2 = e2.ByBase91()
 		case "base100":
-			e = e.ByBase100()
+			e1 = e1.ByBase100()
+			e2 = e2.ByBase100()
 		}
 
-		t.Run(fmt.Sprintf(test.baseX+"_test_%d", index), func(t *testing.T) {
-			assert.Nil(t, e.Error)
-			assert.Equal(t, test.output, e.ToString())
-			assert.Equal(t, test.output, fmt.Sprintf("%s", e))
+		t.Run(fmt.Sprintf(test.baseX+"_e1_test_%d", index), func(t *testing.T) {
+			assert.Nil(t, e1.Error)
+			assert.Equal(t, test.output, e1.ToString())
+			assert.Equal(t, test.output, fmt.Sprintf("%s", e1))
+		})
+
+		t.Run(fmt.Sprintf(test.baseX+"_e2_%d", index), func(t *testing.T) {
+			assert.Nil(t, e2.Error)
+			assert.Equal(t, []byte(test.output), e2.ToBytes())
 		})
 	}
 }
 
-func TestBaseX_Decode_ToString(t *testing.T) {
+func TestBaseX_Decode_String(t *testing.T) {
 	for index, test := range baseXTests {
 		d := Decode.FromString(test.output)
 
@@ -118,15 +134,12 @@ func TestBaseX_Decode_ToString(t *testing.T) {
 			d = d.ByBase100()
 		}
 
-		t.Run(fmt.Sprintf(test.baseX+"_test_%d", index), func(t *testing.T) {
-			assert.Nil(t, d.Error)
-			assert.Equal(t, test.input, d.ToString())
-			assert.Equal(t, test.input, fmt.Sprintf("%s", d))
-		})
+		assert.Nil(t, d.Error)
+		assert.Equal(t, test.input, d.ToString(), "Current test index is "+strconv.Itoa(index))
 	}
 }
 
-func TestBaseX_Encode_ToBytes(t *testing.T) {
+func TestBaseX_Encode_Bytes(t *testing.T) {
 	for index, test := range baseXTests {
 		e := Encode.FromBytes([]byte(test.input))
 
@@ -153,14 +166,12 @@ func TestBaseX_Encode_ToBytes(t *testing.T) {
 			e = e.ByBase100()
 		}
 
-		t.Run(fmt.Sprintf(test.baseX+"_test_%d", index), func(t *testing.T) {
-			assert.Nil(t, e.Error)
-			assert.Equal(t, []byte(test.output), e.ToBytes())
-		})
+		assert.Nil(t, e.Error)
+		assert.Equal(t, []byte(test.output), e.ToBytes(), "Current test index is "+strconv.Itoa(index))
 	}
 }
 
-func TestBaseX_Decode_ToBytes(t *testing.T) {
+func TestBaseX_Decode_Bytes(t *testing.T) {
 	for index, test := range baseXTests {
 		d := Decode.FromBytes([]byte(test.output))
 
@@ -194,7 +205,7 @@ func TestBaseX_Decode_ToBytes(t *testing.T) {
 	}
 }
 
-func TestBaseX_Ciphertext_Error(t *testing.T) {
+func TestBaseX_Decoding_Error(t *testing.T) {
 	tests := []struct {
 		baseX string
 		input string // 输入值
@@ -214,32 +225,48 @@ func TestBaseX_Ciphertext_Error(t *testing.T) {
 	}
 
 	for index, test := range tests {
-		d := Decode.FromString(test.input)
+		d1 := Decode.FromString(test.input)
+		d2 := Decode.FromBytes([]byte(test.input))
+
 		switch test.baseX {
 		case "hex":
-			d = d.ByHex()
+			d1 = d1.ByHex()
+			d2 = d2.ByHex()
 		case "base16":
-			d = d.ByBase16()
+			d1 = d1.ByBase16()
+			d2 = d2.ByBase16()
 		case "base32":
-			d = d.ByBase32()
+			d1 = d1.ByBase32()
+			d2 = d2.ByBase32()
 		case "base58":
-			d = d.ByBase58()
+			d1 = d1.ByBase58()
+			d2 = d2.ByBase58()
 		case "base62":
-			d = d.ByBase62()
+			d1 = d1.ByBase62()
+			d2 = d2.ByBase62()
 		case "base64":
-			d = d.ByBase64()
+			d1 = d1.ByBase64()
+			d2 = d2.ByBase64()
 		case "base64URL":
-			d = d.ByBase64URL()
+			d1 = d1.ByBase64URL()
+			d2 = d2.ByBase64URL()
 		case "base85":
-			d = d.ByBase85()
+			d1 = d1.ByBase85()
+			d2 = d2.ByBase85()
 		case "base91":
-			d = d.ByBase91()
+			d1 = d1.ByBase91()
+			d2 = d2.ByBase91()
 		case "base100":
-			d = d.ByBase100()
+			d1 = d1.ByBase100()
+			d2 = d2.ByBase100()
 		}
 
-		t.Run(fmt.Sprintf(test.baseX+"_test_%d", index), func(t *testing.T) {
-			assert.Equal(t, invalidDecodingError(test.baseX), d.Error)
+		t.Run(fmt.Sprintf(test.baseX+"_d1_test_%d", index), func(t *testing.T) {
+			assert.Equal(t, invalidDecodingError(test.baseX), d1.Error)
+		})
+
+		t.Run(fmt.Sprintf(test.baseX+"_d2_test_%d", index), func(t *testing.T) {
+			assert.Equal(t, invalidDecodingError(test.baseX), d2.Error)
 		})
 	}
 }
diff --git a/bcrypt_test.go b/bcrypt_test.go
index 6513765..611f300 100755
--- a/bcrypt_test.go
+++ b/bcrypt_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 )
 
-func TestBcrypt_ToString(t *testing.T) {
+func TestBcrypt_String(t *testing.T) {
 	s1 := Sign.FromString("").ByBcrypt(10)
 	v1 := Verify.FromRawString(s1.ToRawString(), "").ByBcrypt()
 	assert.Equal(t, false, v1.ToBool())
@@ -24,7 +24,7 @@ func TestBcrypt_ToString(t *testing.T) {
 	assert.Equal(t, true, v4.ToBool())
 }
 
-func TestBcrypt_ToBytes(t *testing.T) {
+func TestBcrypt_Bytes(t *testing.T) {
 	s1 := Sign.FromBytes([]byte("")).ByBcrypt(1)
 	v1 := Verify.FromRawBytes(s1.ToRawBytes(), []byte("")).ByBcrypt()
 	assert.Equal(t, false, v1.ToBool())
@@ -34,7 +34,7 @@ func TestBcrypt_ToBytes(t *testing.T) {
 	assert.Equal(t, true, v2.ToBool())
 }
 
-func TestBcrypt_BcryptRounds_Error(t *testing.T) {
+func TestBcrypt_Rounds_Error(t *testing.T) {
 	s := Sign.FromString("hello world").ByBcrypt(1)
 	assert.Equal(t, invalidBcryptRoundsError(), s.Error)
 }
diff --git a/des_test.go b/des_test.go
index e7714b5..320b13d 100755
--- a/des_test.go
+++ b/des_test.go
@@ -49,7 +49,7 @@ var desTests = []struct {
 	{ECB, PKCS7, "hello world", "28dba02eb5f6dd475d82e3681c83bb77", "KNugLrX23UddguNoHIO7dw=="},
 }
 
-func TestDes_Encrypt_ToString(t *testing.T) {
+func TestDes_Encrypt_String(t *testing.T) {
 	for index, test := range desTests {
 		raw := Decode.FromString(test.toHex).ByHex().ToString()
 		e := Encrypt.FromString(test.input).ByDes(getCipher(test.mode, test.padding, desKey, desIV))
@@ -69,7 +69,7 @@ func TestDes_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestDes_Decrypt_ToString(t *testing.T) {
+func TestDes_Decrypt_String(t *testing.T) {
 	for index, test := range desTests {
 		raw := Decode.FromString(test.toHex).ByHex().ToString()
 		e := Decrypt.FromRawString(raw).ByDes(getCipher(test.mode, test.padding, desKey, desIV))
@@ -102,7 +102,7 @@ func TestDes_Decrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestDes_Encrypt_ToBytes(t *testing.T) {
+func TestDes_Encrypt_Bytes(t *testing.T) {
 	for index, test := range desTests {
 		raw := Decode.FromBytes([]byte(test.toHex)).ByHex().ToBytes()
 		e := Encrypt.FromBytes([]byte(test.input)).ByDes(getCipher(test.mode, test.padding, []byte(desKey), []byte(desIV)))
@@ -122,7 +122,7 @@ func TestDes_Encrypt_ToBytes(t *testing.T) {
 	}
 }
 
-func TestDes_Decrypt_ToBytes(t *testing.T) {
+func TestDes_Decrypt_Bytes(t *testing.T) {
 	for index, test := range desTests {
 		raw := Decode.FromBytes([]byte(test.toHex)).ByHex().ToBytes()
 		e := Decrypt.FromRawBytes(raw).ByDes(getCipher(test.mode, test.padding, []byte(desKey), []byte(desIV)))
diff --git a/hash_test.go b/hash_test.go
index 5b48402..aa61878 100755
--- a/hash_test.go
+++ b/hash_test.go
@@ -56,7 +56,7 @@ var hashTests = []struct {
 	{"ripemd160", "hello world", "98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f", "mMYVeEzLX+WTb7wMvp39tAjZLw8="},
 }
 
-func TestHash_Encrypt_ToString(t *testing.T) {
+func TestHash_Encrypt_String(t *testing.T) {
 	for index, test := range hashTests {
 		e := Encrypt.FromString(test.input)
 
@@ -100,7 +100,7 @@ func TestHash_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestHash_Encrypt_ToBytes(t *testing.T) {
+func TestHash_Encrypt_Bytes(t *testing.T) {
 	for index, test := range hashTests {
 		e := Encrypt.FromBytes([]byte(test.input))
 
@@ -143,7 +143,7 @@ func TestHash_Encrypt_ToBytes(t *testing.T) {
 	}
 }
 
-func TestHash_Digests_Error(t *testing.T) {
+func TestHash_Size_Error(t *testing.T) {
 	e1 := Encrypt.FromString("hello world").BySha3(100)
 	assert.Equal(t, invalidHashSizeError(), e1.Error)
 	e2 := Encrypt.FromBytes([]byte("hello world")).BySha3(100)
diff --git a/hmac_test.go b/hmac_test.go
index 76465b0..a0446ff 100755
--- a/hmac_test.go
+++ b/hmac_test.go
@@ -60,7 +60,7 @@ var hmacTests = []struct {
 	{"sm3", "hello world", "dongle", "8c733aae1d553c466a08c3e9e5daac3e99ae220181c7c1bc8c2564961de751b3", "jHM6rh1VPEZqCMPp5dqsPpmuIgGBx8G8jCVklh3nUbM="},
 }
 
-func TestHmac_Encrypt_ToString(t *testing.T) {
+func TestHmac_Encrypt_String(t *testing.T) {
 	for index, test := range hmacTests {
 		e := Encrypt.FromString(test.input)
 
@@ -106,7 +106,7 @@ func TestHmac_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestHmac_Encrypt_ToBytes(t *testing.T) {
+func TestHmac_Encrypt_Bytes(t *testing.T) {
 	for index, test := range hmacTests {
 		e := Encrypt.FromBytes([]byte(test.input)).ByHmacMd4([]byte(test.key))
 
@@ -151,7 +151,7 @@ func TestHmac_Encrypt_ToBytes(t *testing.T) {
 	}
 }
 
-func TestHmac_Digests_Error(t *testing.T) {
+func TestHmac_Size_Error(t *testing.T) {
 	e1 := Encrypt.FromString("hello world").ByHmacSha3("dongle", 100)
 	assert.Equal(t, invalidHashSizeError(), e1.Error)
 	e2 := Encrypt.FromBytes([]byte("hello world")).ByHmacSha3([]byte("dongle"), 100)
diff --git a/morse_test.go b/morse_test.go
index bd832a1..1179343 100644
--- a/morse_test.go
+++ b/morse_test.go
@@ -20,7 +20,7 @@ var morseTests = []struct {
 	{"SOS", "/", ".../---/..."},
 }
 
-func TestMorse_Encode_ToString(t *testing.T) {
+func TestMorse_Encode_String(t *testing.T) {
 	for index, test := range morseTests {
 		e := Encode.FromString(test.input).ByMorse(test.separator)
 
@@ -31,7 +31,7 @@ func TestMorse_Encode_ToString(t *testing.T) {
 	}
 }
 
-func TestMorse_Decode_ToString(t *testing.T) {
+func TestMorse_Decode_String(t *testing.T) {
 	for index, test := range morseTests {
 		d := Decode.FromString(test.output).ByMorse(test.separator)
 
@@ -42,7 +42,7 @@ func TestMorse_Decode_ToString(t *testing.T) {
 	}
 }
 
-func TestMorse_Encode_ToBytes(t *testing.T) {
+func TestMorse_Encode_Bytes(t *testing.T) {
 	for index, test := range morseTests {
 		e := Encode.FromBytes([]byte(test.input)).ByMorse(test.separator)
 
@@ -53,7 +53,7 @@ func TestMorse_Encode_ToBytes(t *testing.T) {
 	}
 }
 
-func TestMorse_Decode_ToBytes(t *testing.T) {
+func TestMorse_Decode_Bytes(t *testing.T) {
 	for index, test := range morseTests {
 		d := Decode.FromBytes([]byte(test.output)).ByMorse(test.separator)
 
diff --git a/rc4_test.go b/rc4_test.go
index 1432ec7..bbb1b1b 100755
--- a/rc4_test.go
+++ b/rc4_test.go
@@ -16,7 +16,7 @@ var rc4Tests = []struct {
 	{"hello world", "dongle", "eba154b4cb5a9038dbbf9d", "66FUtMtakDjbv50="},
 }
 
-func TestRc4_Encrypt_ToString(t *testing.T) {
+func TestRc4_Encrypt_String(t *testing.T) {
 	for index, test := range rc4Tests {
 		e := Encrypt.FromString(test.input).ByRc4(test.key)
 
@@ -28,19 +28,7 @@ func TestRc4_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestRc4_Encrypt_ToBytes(t *testing.T) {
-	for index, test := range rc4Tests {
-		e := Encrypt.FromBytes([]byte(test.input)).ByRc4([]byte(test.key))
-
-		t.Run(fmt.Sprintf("test_%d", index), func(t *testing.T) {
-			assert.Nil(t, e.Error)
-			assert.Equal(t, []byte(test.toHex), e.ToHexBytes())
-			assert.Equal(t, []byte(test.toBase64), e.ToBase64Bytes())
-		})
-	}
-}
-
-func TestRc4_Decrypt_ToString(t *testing.T) {
+func TestRc4_Decrypt_String(t *testing.T) {
 	for index, test := range rc4Tests {
 		d1 := Decrypt.FromHexString(test.toHex).ByRc4(test.key)
 
@@ -57,7 +45,19 @@ func TestRc4_Decrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestRc4_Decrypt_ToBytes(t *testing.T) {
+func TestRc4_Encrypt_Bytes(t *testing.T) {
+	for index, test := range rc4Tests {
+		e := Encrypt.FromBytes([]byte(test.input)).ByRc4([]byte(test.key))
+
+		t.Run(fmt.Sprintf("test_%d", index), func(t *testing.T) {
+			assert.Nil(t, e.Error)
+			assert.Equal(t, []byte(test.toHex), e.ToHexBytes())
+			assert.Equal(t, []byte(test.toBase64), e.ToBase64Bytes())
+		})
+	}
+}
+
+func TestRc4_Decrypt_Bytes(t *testing.T) {
 	for index, test := range rc4Tests {
 		d1 := Decrypt.FromHexBytes([]byte(test.toHex)).ByRc4([]byte(test.key))
 		t.Run(fmt.Sprintf("test_hex_%d", index), func(t *testing.T) {
diff --git a/rsa_test.go b/rsa_test.go
index 9b4c110..55ddd7e 100644
--- a/rsa_test.go
+++ b/rsa_test.go
@@ -51,7 +51,7 @@ RPgUNaDGIh5o
 -----END PRIVATE KEY-----`
 )
 
-func TestRsa_PKCS1_ToString(t *testing.T) {
+func TestRsa_PKCS1_String(t *testing.T) {
 	e := Encrypt.FromString(rsaInput).ByRsa(pkcs1PublicKey)
 	assert.Nil(t, e.Error)
 	d1 := Decrypt.FromRawString(e.ToRawString()).ByRsa(pkcs1PrivateKey)
@@ -77,7 +77,7 @@ func TestRsa_PKCS1_ToString(t *testing.T) {
 	assert.Equal(t, true, v3.ToBool())
 }
 
-func TestRsa_PKCS1_ToBytes(t *testing.T) {
+func TestRsa_PKCS1_Bytes(t *testing.T) {
 	e := Encrypt.FromBytes([]byte(rsaInput)).ByRsa([]byte(pkcs1PublicKey))
 	assert.Nil(t, e.Error)
 	d1 := Decrypt.FromRawBytes(e.ToRawBytes()).ByRsa([]byte(pkcs1PrivateKey))
@@ -103,7 +103,7 @@ func TestRsa_PKCS1_ToBytes(t *testing.T) {
 	assert.Equal(t, true, v3.ToBool())
 }
 
-func TestRsa_PKCS8_ToString(t *testing.T) {
+func TestRsa_PKCS8_String(t *testing.T) {
 	e := Encrypt.FromString(rsaInput).ByRsa(pkcs8PublicKey)
 	assert.Nil(t, e.Error)
 	d1 := Decrypt.FromRawString(e.ToRawString()).ByRsa(pkcs8PrivateKey)
@@ -129,7 +129,7 @@ func TestRsa_PKCS8_ToString(t *testing.T) {
 	assert.Equal(t, true, v3.ToBool())
 }
 
-func TestRsa_PKCS8_ToBytes(t *testing.T) {
+func TestRsa_PKCS8_Bytes(t *testing.T) {
 	e := Encrypt.FromBytes([]byte(rsaInput)).ByRsa([]byte(pkcs8PublicKey))
 	assert.Nil(t, e.Error)
 	d1 := Decrypt.FromRawBytes(e.ToRawBytes()).ByRsa([]byte(pkcs8PrivateKey))
@@ -155,7 +155,7 @@ func TestRsa_PKCS8_ToBytes(t *testing.T) {
 	assert.Equal(t, true, v3.ToBool())
 }
 
-func TestRsa_Empty_ToString(t *testing.T) {
+func TestRsa_Empty_String(t *testing.T) {
 	empty := ""
 	e := Encrypt.FromString(empty).ByRsa(pkcs1PublicKey)
 	assert.Nil(t, e.Error)
@@ -182,7 +182,7 @@ func TestRsa_Empty_ToString(t *testing.T) {
 	assert.Equal(t, true, v3.ToBool())
 }
 
-func TestRsa_Empty_ToBytes(t *testing.T) {
+func TestRsa_Empty_Bytes(t *testing.T) {
 	empty := ""
 	e := Encrypt.FromBytes([]byte(empty)).ByRsa([]byte(pkcs1PublicKey))
 	assert.Nil(t, e.Error)
diff --git a/safe_url_test.go b/safe_url_test.go
index 358397b..8d7a082 100644
--- a/safe_url_test.go
+++ b/safe_url_test.go
@@ -14,7 +14,7 @@ var safeUrlTestS = []struct {
 	{"www.gouguoyin.cn?sex=男&age=18", "www.gouguoyin.cn%3Fsex%3D%E7%94%B7%26age%3D18"},
 }
 
-func TestSafeURL_Encrypt_ToString(t *testing.T) {
+func TestSafeURL_Encrypt_String(t *testing.T) {
 	for index, test := range safeUrlTestS {
 		e := Encode.FromString(test.input).BySafeURL()
 
@@ -25,7 +25,7 @@ func TestSafeURL_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestSafeURL_Decrypt_ToString(t *testing.T) {
+func TestSafeURL_Decrypt_String(t *testing.T) {
 	for index, test := range safeUrlTestS {
 		e := Decode.FromString(test.output).BySafeURL()
 
@@ -36,7 +36,7 @@ func TestSafeURL_Decrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestSafeURL_Encrypt_ToBytes(t *testing.T) {
+func TestSafeURL_Encrypt_Bytes(t *testing.T) {
 	for index, test := range safeUrlTestS {
 		e := Encode.FromBytes([]byte(test.input)).BySafeURL()
 
@@ -47,7 +47,7 @@ func TestSafeURL_Encrypt_ToBytes(t *testing.T) {
 	}
 }
 
-func TestSafeURL_Decrypt_ToBytes(t *testing.T) {
+func TestSafeURL_Decrypt_Bytes(t *testing.T) {
 	for index, test := range safeUrlTestS {
 		e := Decode.FromBytes([]byte(test.output)).BySafeURL()
 
diff --git a/sm3_test.go b/sm3_test.go
index 59d1ce3..3b4d10b 100644
--- a/sm3_test.go
+++ b/sm3_test.go
@@ -15,7 +15,7 @@ var sm3Tests = []struct {
 	{"hello world", "44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88", "RPAGHmn6b9/CkMSUZUoF3AwFPaflxSuE75Op1n0//4g="},
 }
 
-func TestSm3_Encrypt_ToString(t *testing.T) {
+func TestSm3_Encrypt_String(t *testing.T) {
 	for index, test := range sm3Tests {
 		e := Encrypt.FromString(test.input).BySm3()
 
@@ -27,7 +27,7 @@ func TestSm3_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestSm3_Encrypt_ToBytes(t *testing.T) {
+func TestSm3_Encrypt_Bytes(t *testing.T) {
 	for index, test := range sm3Tests {
 		e := Encrypt.FromBytes([]byte(test.input)).BySm3()
 
diff --git a/tea_test.go b/tea_test.go
index e306a0b..e6c2ab0 100755
--- a/tea_test.go
+++ b/tea_test.go
@@ -19,7 +19,7 @@ var teaTests = []struct {
 	{"hello go", "0123456789abcdef", 64, "3f9a9d3f2f58277f", "P5qdPy9YJ38="},
 }
 
-func TestTea_Encrypt_ToString(t *testing.T) {
+func TestTea_Encrypt_String(t *testing.T) {
 	for index, test := range teaTests {
 		e1 := Encrypt.FromString(test.input).ByTea(test.key, test.rounds)
 		assert.Nil(t, e1.Error)
@@ -35,23 +35,7 @@ func TestTea_Encrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestTea_Encrypt_ToBytes(t *testing.T) {
-	for index, test := range teaTests {
-		e1 := Encrypt.FromBytes([]byte(test.input)).ByTea([]byte(test.key))
-		assert.Nil(t, e1.Error)
-
-		assert.Equal(t, []byte(test.toHex), e1.ToHexBytes(), "Hex test test index is "+strconv.Itoa(index))
-		assert.Equal(t, []byte(test.toBase64), e1.ToBase64Bytes(), "Base64 test index is "+strconv.Itoa(index))
-
-		e2 := Encrypt.FromBytes([]byte(test.input)).ByTea([]byte(test.key), test.rounds)
-		assert.Nil(t, e2.Error)
-
-		assert.Equal(t, []byte(test.toHex), e2.ToHexBytes(), "Hex test test index is "+strconv.Itoa(index))
-		assert.Equal(t, []byte(test.toBase64), e2.ToBase64Bytes(), "Base64 test index is "+strconv.Itoa(index))
-	}
-}
-
-func TestTea_Decrypt_ToString(t *testing.T) {
+func TestTea_Decrypt_String(t *testing.T) {
 	for index, test := range teaTests {
 		d1 := Decrypt.FromHexString(test.toHex).ByTea(test.key)
 		assert.Nil(t, d1.Error)
@@ -71,7 +55,23 @@ func TestTea_Decrypt_ToString(t *testing.T) {
 	}
 }
 
-func TestTea_Decrypt_ToBytes(t *testing.T) {
+func TestTea_Encrypt_Bytes(t *testing.T) {
+	for index, test := range teaTests {
+		e1 := Encrypt.FromBytes([]byte(test.input)).ByTea([]byte(test.key))
+		assert.Nil(t, e1.Error)
+
+		assert.Equal(t, []byte(test.toHex), e1.ToHexBytes(), "Hex test test index is "+strconv.Itoa(index))
+		assert.Equal(t, []byte(test.toBase64), e1.ToBase64Bytes(), "Base64 test index is "+strconv.Itoa(index))
+
+		e2 := Encrypt.FromBytes([]byte(test.input)).ByTea([]byte(test.key), test.rounds)
+		assert.Nil(t, e2.Error)
+
+		assert.Equal(t, []byte(test.toHex), e2.ToHexBytes(), "Hex test test index is "+strconv.Itoa(index))
+		assert.Equal(t, []byte(test.toBase64), e2.ToBase64Bytes(), "Base64 test index is "+strconv.Itoa(index))
+	}
+}
+
+func TestTea_Decrypt_Bytes(t *testing.T) {
 	for index, test := range teaTests {
 		e1 := Decrypt.FromHexBytes([]byte(test.toHex)).ByTea([]byte(test.key), test.rounds)
 		assert.Nil(t, e1.Error)