1 files changed, 58 insertions, 22 deletions

diff --git a/src/tests.rs b/src/tests.rs
index 88748de..7083b54 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -1,11 +1,19 @@
-use crate::{decode_config, encode::encoded_size, encode_config_buf, CharacterSet, Config};
-
 use std::str;
 
 use rand::{
-    distributions::{Distribution, Uniform},
+    distributions,
+    distributions::{Distribution as _, Uniform},
     seq::SliceRandom,
-    FromEntropy, Rng,
+    Rng, SeedableRng,
+};
+
+use crate::{
+    alphabet,
+    encode::encoded_len,
+    engine::{
+        general_purpose::{GeneralPurpose, GeneralPurposeConfig},
+        Config, DecodePaddingMode, Engine,
+    },
 };
 
 #[test]
@@ -19,10 +27,10 @@ fn roundtrip_random_config_long() {
     roundtrip_random_config(Uniform::new(0, 1000), 10_000);
 }
 
-pub fn assert_encode_sanity(encoded: &str, config: Config, input_len: usize) {
+pub fn assert_encode_sanity(encoded: &str, padded: bool, input_len: usize) {
     let input_rem = input_len % 3;
     let expected_padding_len = if input_rem > 0 {
-        if config.pad {
+        if padded {
             3 - input_rem
         } else {
             0
@@ -31,7 +39,7 @@ pub fn assert_encode_sanity(encoded: &str, config: Config, input_len: usize) {
         0
     };
 
-    let expected_encoded_len = encoded_size(input_len, config).unwrap();
+    let expected_encoded_len = encoded_len(input_len, padded).unwrap();
 
     assert_eq!(expected_encoded_len, encoded.len());
 
@@ -53,29 +61,57 @@ fn roundtrip_random_config(input_len_range: Uniform<usize>, iterations: u32) {
 
         let input_len = input_len_range.sample(&mut rng);
 
-        let config = random_config(&mut rng);
+        let engine = random_engine(&mut rng);
 
         for _ in 0..input_len {
             input_buf.push(rng.gen());
         }
 
-        encode_config_buf(&input_buf, config, &mut encoded_buf);
+        engine.encode_string(&input_buf, &mut encoded_buf);
+
+        assert_encode_sanity(&encoded_buf, engine.config().encode_padding(), input_len);
+
+        assert_eq!(input_buf, engine.decode(&encoded_buf).unwrap());
+    }
+}
 
-        assert_encode_sanity(&encoded_buf, config, input_len);
+pub fn random_config<R: Rng>(rng: &mut R) -> GeneralPurposeConfig {
+    let mode = rng.gen();
+    GeneralPurposeConfig::new()
+        .with_encode_padding(match mode {
+            DecodePaddingMode::Indifferent => rng.gen(),
+            DecodePaddingMode::RequireCanonical => true,
+            DecodePaddingMode::RequireNone => false,
+        })
+        .with_decode_padding_mode(mode)
+        .with_decode_allow_trailing_bits(rng.gen())
+}
 
-        assert_eq!(input_buf, decode_config(&encoded_buf, config).unwrap());
+impl distributions::Distribution<DecodePaddingMode> for distributions::Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> DecodePaddingMode {
+        match rng.gen_range(0..=2) {
+            0 => DecodePaddingMode::Indifferent,
+            1 => DecodePaddingMode::RequireCanonical,
+            _ => DecodePaddingMode::RequireNone,
+        }
     }
 }
 
-pub fn random_config<R: Rng>(rng: &mut R) -> Config {
-    const CHARSETS: &[CharacterSet] = &[
-        CharacterSet::UrlSafe,
-        CharacterSet::Standard,
-        CharacterSet::Crypt,
-        CharacterSet::ImapMutf7,
-        CharacterSet::BinHex,
-    ];
-    let charset = *CHARSETS.choose(rng).unwrap();
-
-    Config::new(charset, rng.gen())
+pub fn random_alphabet<R: Rng>(rng: &mut R) -> &'static alphabet::Alphabet {
+    ALPHABETS.choose(rng).unwrap()
 }
+
+pub fn random_engine<R: Rng>(rng: &mut R) -> GeneralPurpose {
+    let alphabet = random_alphabet(rng);
+    let config = random_config(rng);
+    GeneralPurpose::new(alphabet, config)
+}
+
+const ALPHABETS: &[alphabet::Alphabet] = &[
+    alphabet::URL_SAFE,
+    alphabet::STANDARD,
+    alphabet::CRYPT,
+    alphabet::BCRYPT,
+    alphabet::IMAP_MUTF7,
+    alphabet::BIN_HEX,
+];