Add the IsNonsense interface for FrequencyAnalyzer.

.gitlab-ci.yml

@@ -0,0 +1,10 @@
+image: clojure:temurin-11-lein-2.10.0-alpine
+
+stages:
+  - test
+
+unit tests:
+  stage: test
+  script:
+    - lein test
+

src/cipher_analytical_machine/analyzers/analyzers.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.cipher-analyzers
+(ns cipher-analytical-machine.analyzers.analyzers
   (:require [clojure.string :as cs])
   (:gen-class))
 
@@ -21,16 +21,16 @@
 
 (defn chi-squared-statistic
   "To calculate the frequency distribution of a language. More detail about the algorithm here: http://practicalcryptography.com/cryptanalysis/text-characterisation/chi-squared-statistic/"
-  [text letter-frequences]
+  [text letter-frequencies]
   (let [length-text (count text)
         letter-counts (count-characters (cs/lower-case text))]
     ;letter-counts
     (reduce
      (fn [acc [char count]]
        (+ acc
-          (if (contains? letter-frequences char)
+          (if (contains? letter-frequencies char)
             (chi-squared-letter-statistic count
-                                          (get letter-frequences char)
+                                          (get letter-frequencies char)
                                           length-text)
             0)))
             0

src/cipher_analytical_machine/analyzers/caesar.clj

@@ -1,9 +1,11 @@
-(ns cipher-analytical-machine.caesar-analyzers
-  (:require [cipher-analytical-machine.caesar :as caesar]
+(ns cipher-analytical-machine.analyzers.caesar
+  (:require [cipher-analytical-machine.ciphers.caesar :as caesar]
             [clojure.string :as cs]
-            [cipher-analytical-machine.cipher-analyzers :as ca])
+            [cipher-analytical-machine.analyzers.language :as language]
+            [cipher-analytical-machine.analyzers.analyzers :as ca])
   (:import [cipher_analytical_machine.ciphers.caesar Decrypted]
-           [cipher_analytical_machine.analizers.caesar FrequencyAnalyzer])
+           [cipher_analytical_machine.analyzers.caesar IsNonsense]
+           [cipher_analytical_machine.analyzers.caesar FrequencyAnalyzer])
   (:gen-class))
 
 (defn get-all-texts
@@ -17,9 +19,9 @@
 
 (defn get-all-scores
   "For pairs (key, plaintext) finds scores and return list of pairs [key, score]."
-  [letter-frequences pairs]
+  [letter-frequencies pairs]
   (map (fn [[key text]]
-         [key (ca/chi-squared-statistic text letter-frequences)])
+         [key (ca/chi-squared-statistic text letter-frequencies)])
        pairs))
 
 (defn get-min-score-pair
@@ -34,26 +36,29 @@
 
 (defn get-key
   "To find the key with frequencies of letters."
-  [ciphertext symbols letter-frequences]
+  [ciphertext symbols letter-frequencies]
   (->> (get-all-texts ciphertext symbols)
-       (get-all-scores letter-frequences)
+       (get-all-scores letter-frequencies)
        (get-min-score-pair)
        (first)))
 
 (defn get-plaintext
   "Return the plaintext from a ciphertext. The function is case-insensitive."
-  [ciphertext symbols letter-frequences]
+  [ciphertext symbols letter-frequencies]
   (let [ciphertext (cs/lower-case ciphertext)]
     (caesar/decrypt-message ciphertext
-                            (get-key ciphertext symbols letter-frequences)
+                            (get-key ciphertext symbols letter-frequencies)
                             symbols)))
 
 (defn frequency-analizer-get-plaintext
   "Return the plaintext from a ciphertext using simple analizer. The function is case-insensitive."
-  [ciphertext symbols letter-frequences]
+  [ciphertext symbols letter-frequencies-string language-code]
   (let [decrypt (reify Decrypted
                   (decrypt [this message key symbols]
-                    (caesar/decrypt-message message key symbols)))]
-    (-> (new FrequencyAnalyzer ciphertext symbols letter-frequences decrypt)
+                    (caesar/decrypt-message message key symbols)))
+        is-nonsense (reify IsNonsense
+                  (isNonsense [this message]
+                    (language/is-nonsense? message language-code)))]
+    (-> (new FrequencyAnalyzer ciphertext symbols letter-frequencies-string decrypt is-nonsense)
         .crack)))
 

src/cipher_analytical_machine/analyzers/language.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.language-analyzer
+(ns cipher-analytical-machine.analyzers.language
   (:import [org.apache.tika.language LanguageIdentifier])
   (:gen-class))
 

src/cipher_analytical_machine/ciphers/caesar.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.caesar
+(ns cipher-analytical-machine.ciphers.caesar
   (:require [clojure.string :as cs])
   (:gen-class))
 

src/cipher_analytical_machine/cli/cli.clj

@@ -1,36 +1,15 @@
-(ns cipher-analytical-machine.cli
+(ns cipher-analytical-machine.cli.cli
   (:require
-   [cipher-analytical-machine.file :as file]
-   [cipher-analytical-machine.caesar :as caesar]
-   [cipher-analytical-machine.caesar-analyzers :as caesar-analyzers]
-   [cipher-analytical-machine.symbol-factories :as sf]
-   [cipher-analytical-machine.symbol-frequences :as symbol-frequences]
+   [cipher-analytical-machine.cli.file :as file]
+   [cipher-analytical-machine.ciphers.caesar :as caesar]
+   [cipher-analytical-machine.analyzers.caesar :as caesar-analyzers]
+   [cipher-analytical-machine.symbols.factories :as sf]
+   [cipher-analytical-machine.symbols.frequencies :as symbol-frequencies]
+   [cipher-analytical-machine.cli.options :as options]
    [clojure.string :as cs]
    [clojure.tools.cli :refer [parse-opts]])
   (:gen-class))
 
-(def cipher-options
-  #{"Caesar"})
-
-(def language-options
-  #{"en", "uk"})
-
-(def cli-options
-  [["-m" "--message MESSAGE" "The message will be encrypted or decrypted."]
-   ["-M" "--message-file MESSAGE-FILE" "The file contains the message that will be encrypted or decrypted."]
-   ["-k" "--key KEY" "The key will be used to encrypt or decrypt."]
-   ["-c" "--cipher CIPHER" "The cipher will be used to encrypt or decrypt a message."
-    :default "Caesar"]
-   ["-e" "--encrypt" "Encrypt the message."]
-   ["-d" "--decrypt" "Decrypt the message."]
-   ["-s" "--symbols" "The string will be used as a set of symbols for a cipher."
-    :default (sf/default-symbol-factory "en")]
-   ["-l" "--language CODE" "The string will be used to set a default symbols for a cipher."
-    :validate [#(contains? language-options %) "Must be a code from the list: en, uk!!!"]]
-   ["-C" "--cracking" "Cracking the encrypted message."]
-   ["-O" "--output-file OUTPUT-FILE" "Save the program output to a file."]
-   ["-h" "--help"]])
-
 (defn usage [options-summary]
   (->> ["This is cipher-analytical-machine. It can help you to learn how ciphers works."
         ""
@@ -38,6 +17,12 @@
         ""
         "Options:"
         options-summary
+        ""
+        "Available values"
+        ""
+        (options/get-available-cipher-options-as-string)
+        ""
+        (options/get-available-analyzers-options-as-string)
         ""]
        (cs/join \newline)))
 
@@ -55,7 +40,7 @@
   should exit (with an error message, and optional ok status), or a map
   indicating the action the program should take and the options provided."
   [args]
-  (let [{:keys [options arguments errors summary]} (parse-opts args cli-options)]
+  (let [{:keys [options arguments errors summary]} (parse-opts args options/cli-options)]
     (cond
       (:help options)
       {:exit-message (usage summary) :ok? true}
@@ -77,6 +62,16 @@
            (file/is-file-exists? (:output-file options)))
       {:exit-message (error-msg ["Please, choose another file!!! Overwriting was prevented!!!"])}
 
+      (false? (contains? options/cipher-options (:cipher options)))
+      {:exit-message (error-msg ["Please, choose an available cipher!!!\n"
+                                 (options/get-available-cipher-options-as-string)])}
+
+      (and (map-has-keys? options [:cipher, :cracking, :analyzer])
+           (false? (contains?
+             (get options/analyzers-options (:cipher options)) (:analyzer options))))
+      {:exit-message (error-msg ["Please, choose an available analyzer!!!\n"
+                                 (options/get-available-analyzers-options-as-string)])}
+
       (and (map-has-keys? options [:cipher, :key])
            (or (contains? options :message)
                (contains? options :message-file))
@@ -122,8 +117,10 @@
 (defn set-symbols
   "Set defaults symbols for a language."
   [options]
+  (if (contains? options :language)
     (set-option options :symbols
-              (sf/default-symbol-factory (:language options))))
+                (sf/default-symbol-factory (:language options)))
+    options))
 
 (defn load-and-set-option
   "Load the option and set it."
@@ -151,14 +148,27 @@
     (save-output output options))
   (println output))
 
+(defn cracking-caesar
+  [options arguments]
+  (let [analyzer (:analyzer options)
+        message (:message options)
+        symbols (:symbols options)
+        frequencies symbol-frequencies/english-letter-frequencies]
+    (cond
+      (= analyzer "Chi^2")
+      (caesar-analyzers/get-plaintext message symbols frequencies)
+
+      (= analyzer "Frequency")
+      (caesar-analyzers/frequency-analizer-get-plaintext message symbols
+                                                         (symbol-frequencies/map-to-string frequencies)
+                                                         (:language options "en")))))
+
 (defn cracking-actions
   [options arguments action-type]
-  (let [message (:message options)
-        symbols (:symbols options)
-        frequencies symbol-frequences/english-letter-frequences]
+  (let [cipher (:cipher options)]
     (cond
-      (= action-type :cracking)
-      (caesar-analyzers/get-plaintext message symbols frequencies)
+      (= cipher "Caesar")
+      (cracking-caesar options arguments)
       )))
 
 (defn crypt-actions

src/cipher_analytical_machine/cli/file.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.file
+(ns cipher-analytical-machine.cli.file
   (:require [clojure.java.io :as io])
   (:gen-class))
 

src/cipher_analytical_machine/cli/options.clj

@@ -0,0 +1,64 @@
+(ns cipher-analytical-machine.cli.options
+  (:require
+   [cipher-analytical-machine.symbols.factories :as sf]
+   [clojure.string :as cs])
+  (:gen-class))
+
+(defn option-values-as-row
+  "Return the formatted string of values for an option."
+  [option values]
+  (str option ": " (cs/join ", " values)))
+
+(defn option-values-as-list
+  "Return the formatted string of values for an option as a multiline list."
+  [option values]
+  (str option ": \n - " (cs/join "\n - " values)))
+
+(defn map-of-option-value-as-list
+  "Return the formatted string of values for an option as a multiline list.
+   The values are a map of pairs (suboption and its options)."
+  [option values]
+  (let [values (map #(apply option-values-as-row %) values)]
+    (option-values-as-list option values)))
+
+(def cipher-options
+  #{"Caesar"})
+
+(def default-cipher "Caesar")
+
+(defn get-available-cipher-options-as-string
+  "Return the formatted string of analyzers options."
+  []
+  (option-values-as-row "Ciphers" cipher-options))
+
+(def analyzers-options
+  {"Caesar" #{"Chi^2" "Frequency"}})
+
+(defn get-available-analyzers-options-as-string
+  "Return the formatted string of analyzers options."
+  []
+  (map-of-option-value-as-list "Analyzers" analyzers-options))
+
+(def language-options
+  #{"en", "uk"})
+
+(def default-symbols
+  (sf/default-symbol-factory "en"))
+
+(def cli-options
+  [["-m" "--message MESSAGE" "The message will be encrypted or decrypted."]
+   ["-M" "--message-file MESSAGE-FILE" "The file contains the message that will be encrypted or decrypted."]
+   ["-k" "--key KEY" "The key will be used to encrypt or decrypt."]
+   ["-c" "--cipher CIPHER" "The cipher will be used to encrypt or decrypt a message."
+    :default default-cipher]
+   ["-e" "--encrypt" "Encrypt the message."]
+   ["-d" "--decrypt" "Decrypt the message."]
+   ["-s" "--symbols SYMBOLS" "The string will be used as a set of symbols for a cipher."
+    :default default-symbols]
+   ["-l" "--language CODE" "The string will be used to set a default symbols for a cipher."
+    :validate [#(contains? language-options %) "Must be a code from the list: en, uk!!!"]]
+   ["-C" "--cracking" "Cracking the encrypted message."]
+   ["-a" "--analyzer ANALYZER" "The way of cracking."]
+   ["-O" "--output-file OUTPUT-FILE" "Save the program output to a file."]
+   ["-h" "--help"]])
+

src/cipher_analytical_machine/core.clj

@@ -1,6 +1,6 @@
 (ns cipher-analytical-machine.core
   (:require
-   [cipher-analytical-machine.cli :as cli])
+   [cipher-analytical-machine.cli.cli :as cli])
   (:gen-class))
 
 (defn -main

src/cipher_analytical_machine/symbols/factories.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.symbol-factories
+(ns cipher-analytical-machine.symbols.factories
   (:require [clojure.string :as cs])
   (:gen-class))
 

src/cipher_analytical_machine/symbols/frequencies.clj

@@ -1,7 +1,17 @@
-(ns cipher-analytical-machine.symbol-frequences
+(ns cipher-analytical-machine.symbols.frequencies
   (:gen-class))
 
-(def english-letter-frequences {
+(defn map-to-string
+  "Convert the map of frequencies to the frequency string. Letters are sorted by frequency in descending order."
+  [frequency-map]
+  (->> frequency-map
+       (reduce (fn [acc el] (conj acc el)) [])
+       (sort-by last)
+       (map first)
+       (reverse)
+       (apply str)))
+
+(def english-letter-frequencies {
    \a 0.0804
    \b 0.0154
    \c 0.0306
@@ -30,7 +40,7 @@
    \z 0.0009
 })
 
-(def ukrainian-letter-frequences {
+(def ukrainian-letter-frequencies {
    \а 0.064
    \б 0.013
    \в 0.046

src/main/java/cipher_analytical_machine/analizers/caesar/FrequencyAnalyzer.java

@@ -1,23 +0,0 @@
-package cipher_analytical_machine.analizers.caesar;
-
-import cipher_analytical_machine.ciphers.caesar.Decrypted;
-import java.util.Map;
-
-public class FrequencyAnalyzer {
-    private String ciphertext;
-    private int key;
-    private String symbols;
-    private Decrypted decryptor;
-
-    public FrequencyAnalyzer(String ciphertext, String symbols, Map<Character, Double> symbol_frequences, Decrypted decryptor) {
-	this.ciphertext = ciphertext;
-	this.key = 1;
-	this.symbols = symbols;
-	this.decryptor = decryptor;
-    }
-
-    public String crack() {
-	return decryptor.decrypt(ciphertext, key, symbols);
-    }
-}
-

src/main/java/cipher_analytical_machine/analyzers/caesar/FrequencyAnalyzer.java

@@ -0,0 +1,53 @@
+package cipher_analytical_machine.analyzers.caesar;
+
+import cipher_analytical_machine.analyzers.caesar.IsNonsense;
+import cipher_analytical_machine.ciphers.caesar.Decrypted;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class FrequencyAnalyzer {
+    private String ciphertext;
+    private String symbols;
+    private String symbol_frequences;
+    private Decrypted decryptor;
+    private IsNonsense isNonsense;
+
+    public FrequencyAnalyzer(String ciphertext, String symbols, String symbol_frequences, Decrypted decryptor, IsNonsense isNonsense) {
+	    this.ciphertext = ciphertext;
+        this.symbol_frequences = symbol_frequences;
+        this.symbols = symbols;
+	    this.decryptor = decryptor;
+	    this.isNonsense = isNonsense;
+    }
+
+    public String crack() {
+        // Знаходимо кількість літер
+        Map<Character, Integer> encryptedLetterCounts = new HashMap<>();
+
+        for (char c : ciphertext.toLowerCase().toCharArray()) {
+            encryptedLetterCounts.put(c, encryptedLetterCounts.getOrDefault(c, 0) + 1);
+        }
+
+        // Знаходимо букву, яка зустрічається найчастіше
+        char mostFrequentEncryptedLetter = ' ';
+        int mostFrequentEncryptedLetterCount = 0;
+
+        for (Entry<Character, Integer> entry : encryptedLetterCounts.entrySet()) {
+            if (entry.getValue() > mostFrequentEncryptedLetterCount) {
+                mostFrequentEncryptedLetter = entry.getKey();
+                mostFrequentEncryptedLetterCount = entry.getValue();
+            }
+        }
+
+        // Обчислимо зміщення
+        int size = symbols.length();
+        int indexOfMostFrequentEncryptedLetter = symbols.indexOf(mostFrequentEncryptedLetter);
+        int indexOfMostFrequentLetter = symbols.indexOf(symbol_frequences.charAt(0));
+        int shift = (indexOfMostFrequentEncryptedLetter - indexOfMostFrequentLetter) % size;
+
+        return decryptor.decrypt(ciphertext, shift, symbols);
+    }
+}
+

src/main/java/cipher_analytical_machine/analyzers/caesar/IsNonsense.java

@@ -0,0 +1,6 @@
+package cipher_analytical_machine.analyzers.caesar;
+
+public interface IsNonsense {
+    boolean isNonsense(String message);
+}
+

test/cipher_analytical_machine/analyzers/caesar_test.clj

@@ -1,9 +1,9 @@
-(ns cipher-analytical-machine.caesar-analyzers-test
+(ns cipher-analytical-machine.analyzers.caesar-test
   (:require
    [clojure.test :refer :all]
-   [cipher-analytical-machine.caesar-analyzers :refer :all]
-   [cipher-analytical-machine.symbol-frequences :as sf]
-   [cipher-analytical-machine.cipher-analyzers :as ca]
+   [cipher-analytical-machine.analyzers.caesar :refer :all]
+   [cipher-analytical-machine.symbols.frequencies :as sf]
+   [cipher-analytical-machine.analyzers.analyzers :as ca]
    [clojure.string :as cs]))
 
 (deftest get-all-texts-test
@@ -25,9 +25,9 @@
   (testing "There're 27 combinations for a 'Hello World'."
     (let [ciphertext "khoorczruog"
           symbols "abcdefghijklmnopqrstuvwxyz "
-          frequences sf/english-letter-frequences
+          frequencies sf/english-letter-frequencies
           text-pairs (get-all-texts ciphertext symbols)]
-      (is (= 27 (count (get-all-scores frequences text-pairs)))))))
+      (is (= 27 (count (get-all-scores frequencies text-pairs)))))))
 
 (deftest get-min-score-pair-test
   (testing "If a key is one, then the min score pair is 15."
@@ -40,47 +40,47 @@
         ciphertext "khoorczruog"
         key 3
         symbols "abcdefghijklmnopqrstuvwxyz "
-        frequences sf/english-letter-frequences]
+        frequencies sf/english-letter-frequencies]
     (testing "The plaintext is encrypted with 3 as the key."
-      (is (= key (get-key ciphertext symbols frequences)))))
+      (is (= key (get-key ciphertext symbols frequencies)))))
 
   (let [; З поеми "Кавказ" Тараса Григоровича Шевченка:
         plaintext "Борітеся – поборете, Вам Бог помагає! За вас правда, за вас слава. І воля святая!"
         ciphertext "жхчощйшде–ецхжхчйщй,езєуежхиецхуєиєк!емєезєшецчєзїє,емєезєшештєзє.еоезхтдешздщєд!"
         key 7
         symbols "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя "
-        frequences sf/ukrainian-letter-frequences]
+        frequencies sf/ukrainian-letter-frequencies]
     (testing "The plaintext is encrypted with 3 as the key."
-      (is (= key (get-key ciphertext symbols frequences))))))
+      (is (= key (get-key ciphertext symbols frequencies))))))
 
 (deftest get-plaintext-test
   (let [plaintext "hello world"
         ciphertext "khoorczruog"
         symbols "abcdefghijklmnopqrstuvwxyz "
-        frequences sf/english-letter-frequences]
+        frequencies sf/english-letter-frequencies]
     (testing "The plaintext is encrypted with 3 as the key."
-      (is (= plaintext (get-plaintext ciphertext symbols frequences))))
+      (is (= plaintext (get-plaintext ciphertext symbols frequencies))))
 
     (testing "The ciphertext is case-insensitive."
-      (is (= plaintext (get-plaintext "KhoorcZruog" symbols frequences)))))
+      (is (= plaintext (get-plaintext "KhoorcZruog" symbols frequencies)))))
 
   (let [; З поеми "Кавказ" Тараса Григоровича Шевченка:
         plaintext "Борітеся – поборете, Вам Бог помагає! За вас правда, за вас слава. І воля святая!"
         ciphertext "жхчощйшде–ецхжхчйщй,езєуежхиецхуєиєк!емєезєшецчєзїє,емєезєшештєзє.еоезхтдешздщєд!"
         key 7
         symbols "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя "
-        frequences sf/ukrainian-letter-frequences]
+        frequencies sf/ukrainian-letter-frequencies]
     (testing "The ciphertext is case-insensitive."
       (is (= (cs/lower-case plaintext)
-             (get-plaintext ciphertext symbols frequences))))))
+             (get-plaintext ciphertext symbols frequencies))))))
 
 (deftest frequency-analizer-get-plaintext-test
   (let [plaintext "abc"
         ciphertext "bca"
         key 1
         symbols "abc"
-        frequences sf/english-letter-frequences]
+        frequencies "etaoinsrhldcumfpgwybvkxjqz"]
     (testing "The ciphertext is 'bca' and key is 1."
       (is (= plaintext
-             (frequency-analizer-get-plaintext ciphertext symbols frequences))))))
+             (frequency-analizer-get-plaintext ciphertext symbols frequencies))))))
 

test/cipher_analytical_machine/analyzers/language_test.clj

@@ -1,7 +1,7 @@
-(ns cipher-analytical-machine.language-analyzer-test
+(ns cipher-analytical-machine.analyzers.language-test
   (:require
    [clojure.test :refer :all]
-   [cipher-analytical-machine.language-analyzer :refer :all]
+   [cipher-analytical-machine.analyzers.language :refer :all]
   ))
 
 (deftest detect-language-test

test/cipher_analytical_machine/cipher_analyzers_test.clj

@@ -1,25 +0,0 @@
-(ns cipher-analytical-machine.cipher-analyzers-test
-  (:require
-   [clojure.test :refer :all]
-   [cipher-analytical-machine.cipher-analyzers :refer :all]))
-
-(deftest count-characters-test
-  (testing "Count two dublicates and one uniq character from a string."
-    (is (= {\a 2 \b 1}
-           (count-characters "aba")))))
-
-(deftest chi-squared-letter-statistic-test
-  (testing "If the frequence of A is 0.1, the text length is 100 and contains 20 times, then the chi-squared is 10."
-    (is (= 10.0
-           (chi-squared-letter-statistic 20 0.1 100))))
-
-  (testing "If the frequence of A is 0.1, the text length is 10 and contains 5 times, then the chi-squared is 16.0."
-    (is (= 16.0
-           (chi-squared-letter-statistic 5 0.1 10)))))
-
-(deftest chi-squared-statistic-test
-  (let [text "aaaaabbbbb"]
-  (testing "If the frequences of a and b is 0.1, the text length is 10 and contains them 5 times, then score is 32."
-    (is (= 32.0
-           (chi-squared-statistic text {\a 0.1 \b 0.1}))))))
-

test/cipher_analytical_machine/ciphers/caesar_test.clj

@@ -1,7 +1,7 @@
-(ns cipher-analytical-machine.caesar-test
+(ns cipher-analytical-machine.ciphers.caesar-test
   (:require
    [clojure.test :refer :all]
-   [cipher-analytical-machine.caesar :refer :all]
+   [cipher-analytical-machine.ciphers.caesar :refer :all]
   ))
 
 (deftest calculate-char-index-test

test/cipher_analytical_machine/symbols/factories_test.clj

@@ -1,7 +1,7 @@
-(ns cipher-analytical-machine.symbol-factories-test
+(ns cipher-analytical-machine.symbols.factories-test
   (:require
    [clojure.test :refer :all]
-   [cipher-analytical-machine.symbol-factories :refer :all]
+   [cipher-analytical-machine.symbols.factories :refer :all]
   ))
 
 (deftest english-alphabet-factory-test

test/cipher_analytical_machine/symbols/frequencies_test.clj

@@ -0,0 +1,11 @@
+(ns cipher-analytical-machine.symbols.frequencies-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.symbols.frequencies :refer :all]))
+
+(deftest calculate-char-index-test
+  (let [symbol-map english-letter-frequencies]
+    (testing "The map must be converted to 'etaoinsrhldcumfpgwybvkxjqz'"
+      (is (= "etaoinsrhldcumfpgwybvkxjqz"
+             (map-to-string symbol-map))))))
+