test: add some tests

Author: leeqvip

md5_test.go

@@ -15,3 +15,9 @@ func TestMd5(t *testing.T) {
 	contentMD5 := base64.StdEncoding.EncodeToString([]byte(dst))
 	t.Log(contentMD5)
 }
+
+func TestMd5ToString(t *testing.T) {
+	src := "apple"
+	dst := Md5ToString(src)
+	assert.Equal(t, "1f3870be274f6c49b3e31a0c6728957f", dst)
+}

padding_test.go

@@ -44,3 +44,141 @@ func TestPKCS7UnPadding(t *testing.T) {
 		})
 	}
 }
+
+func TestPadding(t *testing.T) {
+	blockSize := 16
+	tests := []struct {
+		name    string
+		padding string
+		src     []byte
+		wantLen int
+	}{
+		{name: "PKCS5", padding: PKCS5_PADDING, src: []byte("test"), wantLen: 16},
+		{name: "PKCS7", padding: PKCS7_PADDING, src: []byte("test"), wantLen: 16},
+		{name: "Zeros", padding: ZEROS_PADDING, src: []byte("test"), wantLen: 16},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := Padding(tt.padding, tt.src, blockSize)
+			assert.Equal(t, tt.wantLen, len(got))
+		})
+	}
+}
+
+func TestUnPadding(t *testing.T) {
+	blockSize := 16
+	padding := PKCS7_PADDING
+	tests := []struct {
+		name    string
+		src     []byte
+		want    []byte
+		wantErr bool
+	}{
+		{name: "valid padding", src: PKCS7Padding([]byte("test"), blockSize), want: []byte("test"), wantErr: false},
+		{name: "empty src", src: []byte{}, want: []byte{}, wantErr: true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := UnPadding(padding, tt.src)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestPKCS5Padding(t *testing.T) {
+	blockSize := 16
+	tests := []struct {
+		name    string
+		src     []byte
+		wantLen int
+	}{
+		{name: "test PKCS5", src: []byte("test"), wantLen: 16},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PKCS5Padding(tt.src, blockSize)
+			assert.Equal(t, tt.wantLen, len(got))
+		})
+	}
+}
+
+func TestPKCS5Unpadding(t *testing.T) {
+	blockSize := 16
+	padded := PKCS5Padding([]byte("test"), blockSize)
+	tests := []struct {
+		name    string
+		src     []byte
+		want    []byte
+		wantErr bool
+	}{
+		{name: "valid padding", src: padded, want: []byte("test"), wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := PKCS5Unpadding(tt.src)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestPKCS7Padding(t *testing.T) {
+	blockSize := 16
+	tests := []struct {
+		name    string
+		src     []byte
+		wantLen int
+	}{
+		{name: "test PKCS7", src: []byte("test"), wantLen: 16},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PKCS7Padding(tt.src, blockSize)
+			assert.Equal(t, tt.wantLen, len(got))
+		})
+	}
+}
+
+func TestZerosPadding(t *testing.T) {
+	blockSize := 16
+	tests := []struct {
+		name    string
+		src     []byte
+		wantLen int
+	}{
+		{name: "test Zeros", src: []byte("test"), wantLen: 16},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := ZerosPadding(tt.src, blockSize)
+			assert.Equal(t, tt.wantLen, len(got))
+		})
+	}
+}
+
+func TestZerosUnPadding(t *testing.T) {
+	blockSize := 16
+	tests := []struct {
+		name string
+		src  []byte
+		want []byte
+	}{
+		{name: "test ZerosUnPadding", src: ZerosPadding([]byte("test"), blockSize), want: []byte("test")},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ZerosUnPadding(tt.src)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

rsa_test.go

@@ -3,6 +3,9 @@ package openssl
 import (
 	"bytes"
 	"crypto"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
 	"encoding/base64"
 	"testing"
 
@@ -52,3 +55,35 @@ func TestRSASign(t *testing.T) {
 	err = RSAVerify(src, sign, pubBuf.Bytes(), crypto.SHA256)
 	assert.NoError(t, err)
 }
+
+func TestRSAGenerateKey(t *testing.T) {
+	priBuf := bytes.NewBuffer(nil)
+	err := RSAGenerateKey(2048, priBuf)
+	assert.NoError(t, err)
+
+	block, _ := pem.Decode(priBuf.Bytes())
+	assert.NotNil(t, block, "Failed to decode private key")
+	assert.Equal(t, "RSA PRIVATE KEY", block.Type, "Invalid key type")
+
+	_, err = x509.ParsePKCS1PrivateKey(block.Bytes)
+	assert.NoError(t, err, "Failed to parse private key")
+}
+
+func TestRSAGeneratePublicKey(t *testing.T) {
+	priBuf := bytes.NewBuffer(nil)
+	err := RSAGenerateKey(2048, priBuf)
+	assert.NoError(t, err)
+
+	pubBuf := bytes.NewBuffer(nil)
+	err = RSAGeneratePublicKey(priBuf.Bytes(), pubBuf)
+	assert.NoError(t, err)
+
+	block, _ := pem.Decode(pubBuf.Bytes())
+	assert.NotNil(t, block, "Failed to decode public key")
+	assert.Equal(t, "RSA PUBLIC KEY", block.Type, "Invalid key type")
+
+	pubKey, err := x509.ParsePKIXPublicKey(block.Bytes)
+	assert.NoError(t, err, "Failed to parse public key")
+	_, ok := pubKey.(*rsa.PublicKey)
+	assert.True(t, ok, "Key is not an RSA public key")
+}