Merge pull request #259 from task4233/add-tests-for-polybius-cipher

Add tests for polybius cipher

Author: vedantmamgain

ciphers/polybius/polybius.go

@@ -0,0 +1,88 @@
+// Package polybius is encrypting method with polybius square
+// ref: https://en.wikipedia.org/wiki/Polybius_square#Hybrid_Polybius_Playfair_Cipher
+package polybius
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+// Polybius is struct having size, characters, and key
+type Polybius struct {
+	size       int
+	characters string
+	key        string
+}
+
+// NewPolybius returns a pointer to object of Polybius.
+// If the size of "chars" is longer than "size",
+// "chars" are truncated to "size".
+func NewPolybius(key string, size int, chars string) (*Polybius, error) {
+	key = strings.ToUpper(key)
+	chars = strings.ToUpper(chars)[:size]
+	for idx, ch := range chars {
+		if strings.Contains(chars[idx+1:], string(ch)) {
+			return nil, fmt.Errorf("\"chars\" contains same character: %c", ch)
+		}
+	}
+
+	if len(key) != size*size {
+		return nil, fmt.Errorf("len(key): %d must be as long as size squared: %d", len(key), size*size)
+	}
+	return &Polybius{size, chars, key}, nil
+}
+
+// Encrypt encrypts with polybius encryption
+func (p *Polybius) Encrypt(text string) (string, error) {
+	chars := []rune(strings.ToUpper(text))
+	encryptedText := ""
+	for _, char := range chars {
+		encryptedChar, err := p.encipher(char)
+		if err != nil {
+			return "", fmt.Errorf("failed encipher: %w", err)
+		}
+		encryptedText += encryptedChar
+	}
+	return encryptedText, nil
+}
+
+// Decrypt decrypts with polybius encryption
+func (p *Polybius) Decrypt(text string) (string, error) {
+	chars := []rune(strings.ToUpper(text))
+	decryptedText := ""
+	for i := 0; i < len(chars); i += 2 {
+		decryptedChar, err := p.decipher(chars[i:int(math.Min(float64(i+2), float64(len(chars))))])
+		if err != nil {
+			return "", fmt.Errorf("failed decipher: %w", err)
+		}
+		decryptedText += decryptedChar
+	}
+	return decryptedText, nil
+}
+
+func (p *Polybius) encipher(char rune) (string, error) {
+	index := strings.IndexRune(p.key, char)
+	if index < 0 {
+		return "", fmt.Errorf("%c does not exist in keys", char)
+	}
+	row := index / p.size
+	col := index % p.size
+	chars := []rune(p.characters)
+	return string([]rune{chars[row], chars[col]}), nil
+}
+
+func (p *Polybius) decipher(chars []rune) (string, error) {
+	if len(chars) != 2 {
+		return "", fmt.Errorf("the size of \"chars\" must be even")
+	}
+	row := strings.IndexRune(p.characters, chars[0])
+	if row < 0 {
+		return "", fmt.Errorf("%c does not exist in characters", chars[0])
+	}
+	col := strings.IndexRune(p.characters, chars[1])
+	if col < 0 {
+		return "", fmt.Errorf("%c does not exist in characters", chars[1])
+	}
+	return string([]rune(p.key)[row*p.size+col]), nil
+}

ciphers/polybius/polybius_test.go

@@ -0,0 +1,152 @@
+package polybius_test
+
+import (
+	"TheAlgorithms/Go/ciphers/polybius"
+	"fmt"
+	"log"
+	"testing"
+)
+
+func ExampleNewPolybius() {
+	// initialize
+	const (
+		plainText  = "HogeFugaPiyoSpam"
+		size       = 5
+		characters = "HogeF"
+		key        = "abcdefghijklmnopqrstuvwxy"
+	)
+	p, err := polybius.NewPolybius(key, size, characters)
+	if err != nil {
+		log.Fatalf("failed NewPolybius: %v", err)
+	}
+	encryptedText, err := p.Encrypt(plainText)
+	if err != nil {
+		log.Fatalf("failed Encrypt: %v", err)
+	}
+	fmt.Printf("Encrypt=> plainText: %s, encryptedText: %s\n", plainText, encryptedText)
+
+	decryptedText, err := p.Decrypt(encryptedText)
+	if err != nil {
+		log.Fatalf("failed Decrypt: %v", err)
+	}
+	fmt.Printf("Decrypt=> encryptedText: %s, decryptedText: %s\n", encryptedText, decryptedText)
+
+	// Output:
+	// Encrypt=> plainText: HogeFugaPiyoSpam, encryptedText: OGGFOOHFOHFHOOHHEHOEFFGFEEEHHHGG
+	// Decrypt=> encryptedText: OGGFOOHFOHFHOOHHEHOEFFGFEEEHHHGG, decryptedText: HOGEFUGAPIYOSPAM
+}
+
+func TestNewPolybius(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name       string
+		size       int
+		characters string
+		key        string
+		wantErr    string
+	}{
+		{
+			name: "correct initalization", size: 5, characters: "HogeF", key: "abcdefghijklmnopqrstuvwxy", wantErr: "",
+		},
+		{
+			name: "truncate characters", size: 5, characters: "HogeFuga", key: "abcdefghijklmnopqrstuvwxy", wantErr: "",
+		},
+		{
+			name: "invaid key", size: 5, characters: "HogeFuga", key: "abcdefghi", wantErr: "len(key): 9 must be as long as size squared: 25",
+		},
+		{
+			name: "invalid characters", size: 5, characters: "HogeH", key: "abcdefghijklmnopqrstuvwxy", wantErr: "\"chars\" contains same character: H",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := polybius.NewPolybius(tc.key, tc.size, tc.characters)
+			if err != nil && err.Error() != tc.wantErr {
+				t.Errorf("failed NewPolybius: %v", err)
+			}
+		})
+	}
+}
+
+func TestPolybiusEncrypt(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name string
+		text string
+		want string
+	}{
+		{
+			name: "correct encryption", text: "HogeFugaPiyoSpam", want: "OGGFOOHFOHFHOOHHEHOEFFGFEEEHHHGG",
+		},
+		{
+			name: "invalid encryption", text: "hogz", want: "failed encipher: Z does not exist in keys",
+		},
+	}
+	// initialize
+	const (
+		size       = 5
+		characters = "HogeF"
+		key        = "abcdefghijklmnopqrstuvwxy"
+	)
+	p, err := polybius.NewPolybius(key, size, characters)
+	if err != nil {
+		t.Fatalf("failed NewPolybius: %v", err)
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			encrypted, err := p.Encrypt(tc.text)
+			if err != nil {
+				if err.Error() != tc.want {
+					t.Errorf("failed Encrypt: %v", err)
+				}
+			} else if encrypted != tc.want {
+				t.Errorf("Encrypt: %v, want: %v", encrypted, tc.want)
+			}
+		})
+	}
+}
+
+func TestPolybiusDecrypt(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name string
+		text string
+		want string
+	}{
+		{
+			name: "correct decryption", text: "OGGFOOHFOHFHOOHHEHOEFFGFEEEHHHGG", want: "HOGEFUGAPIYOSPAM",
+		},
+		{
+			name: "invalid decryption(position of even number)", text: "hogz", want: "failed decipher: Z does not exist in characters",
+		},
+		{
+			name: "invalid decryption(position of odd number)", text: "hode", want: "failed decipher: D does not exist in characters",
+		},
+		{
+			name: "invalid text size which is odd", text: "hog", want: "failed decipher: the size of \"chars\" must be even",
+		},
+	}
+	// initialize
+	const (
+		size       = 5
+		characters = "HogeF"
+		key        = "abcdefghijklmnopqrstuvwxy"
+	)
+	p, err := polybius.NewPolybius(key, size, characters)
+	if err != nil {
+		t.Fatalf("failed NewPolybius: %v", err)
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			encrypted, err := p.Decrypt(tc.text)
+			if err != nil {
+				if err.Error() != tc.want {
+					t.Errorf("failed Encrypt: %v", err)
+				}
+			} else if encrypted != tc.want {
+				t.Errorf("Encrypt: %v, want: %v", encrypted, tc.want)
+			}
+		})
+	}
+}