Yeah print statements are for plebs, but I'm not bothered to add in a logging framework.

Also, it works.
- The tests probably indicate that the function signatures need to be
adapted, but whatever.

src/storage.rs

@@ -1,5 +1,4 @@
 use crate::hufftree::canonical::CanonicalHufftree;
-use bimap::BiMap;
 use bit_vec::BitVec;
 use std::io::Read;
 use std::io::Write;
@@ -77,15 +76,15 @@ pub fn read_tree_and_text<F: Read>(reader: &mut F) -> String {
 
     let mut c: [u8; 4] = [0; 4];
     while char_and_code[0..4] != [255, 255, 255, 255] {
-        println!("Char and code (start):\n{:?}\n", char_and_code);
+        // println!("Char and code (start):\n{:?}\n", char_and_code);
         c.clone_from_slice(&char_and_code[4..8]);
 
-        println!("Character: {:?}", c);
+        // println!("Character: {:?}", c);
         let c: String = String::from_utf8(Vec::from(c)).expect("Corrupted data 🪳");
         // There should only be one character per 4 bytes.
         let c = c.chars().next().expect("Corrupted data 🪳");
         // let code = BitVec::from_bytes(&char_and_code[0..4]);
-        let mut code = [0;4];
+        let mut code = [0; 4];
         code.clone_from_slice(&char_and_code[0..4]);
         // println!("Character: {:?}", c);
 
@@ -94,31 +93,31 @@ pub fn read_tree_and_text<F: Read>(reader: &mut F) -> String {
         length_of_file_in_bits -= 64;
 
         // For small encodings
-        if length_of_file_in_bits < 64 {
+        if length_of_file_in_bits < 64 || length_of_file_in_bits == 64 {
             break;
         }
         reader
             .read_exact(&mut char_and_code)
             .expect("Could not read further.");
-        println!("Char and code:\n{:?}\n", char_and_code);
+        // println!("Char and code:\n{:?}\n", char_and_code);
     }
-    println!("Char and code:\n{:?}\n", char_and_code);
+    // println!("Char and code:\n{:?}\n", char_and_code);
     length_of_file_in_bits -= 32;
 
-    println!("Length of file remaining: {}", length_of_file_in_bits);
+    // println!("Length of file remaining: {}", length_of_file_in_bits);
 
-    if length_of_file_in_bits < 32 {
+    if length_of_file_in_bits < 32 || length_of_file_in_bits == 32 {
         let mut rest_of_binary = Vec::new();
         reader
             .read_to_end(&mut rest_of_binary)
             .expect("Could not read data to end.");
-        println!("Rest of binary: {:?}", rest_of_binary);
+        // println!("Rest of binary: {:?}", rest_of_binary);
         let rest_of_binary = &rest_of_binary[4..];
-        println!("Rest of binary: {:?}", rest_of_binary);
+        // println!("Rest of binary: {:?}", rest_of_binary);
 
         let mut bits = BitVec::from_bytes(rest_of_binary);
         bits.split_off(length_of_file_in_bits as usize);
-        println!("Bit vec: {:?}", bits);
+        // println!("Bit vec: {:?}", bits);
 
         let can_tree = CanonicalHufftree::from_vec(working_vec);
         return can_tree.decode_text(bits).unwrap();
@@ -131,8 +130,10 @@ pub fn read_tree_and_text<F: Read>(reader: &mut F) -> String {
         .expect("Could not read till EOF.");
 
     let mut rest_of_encoded_text = BitVec::from_bytes(&rest_of_encoded_text);
-    rest_of_encoded_text.split_off(length_of_file_in_bits as usize);
+    // println!("Bit vec: {:?}", rest_of_encoded_text);
     encoded_text.append(&mut rest_of_encoded_text);
+    encoded_text.split_off(length_of_file_in_bits as usize);
+    // println!("Encoded text: {:?}", encoded_text);
 
     let can_tree = CanonicalHufftree::from_vec(working_vec);
     can_tree.decode_text(encoded_text).unwrap()
@@ -175,7 +176,7 @@ mod test {
         let mut virtual_buffer = Vec::new();
         store_tree_and_text(canonical, &mut virtual_buffer, &input_text).unwrap();
 
-        println!("Buffer:{:?}", virtual_buffer);
+        // println!("Buffer:{:?}", virtual_buffer);
         assert_eq!(&virtual_buffer[0..4], &[0, 0, 0, 233]); // Length of tree + encoded text.
                                                             // 0,0,0,1, //  Code length of 'a'
                                                             // 97,0,0,0, // 'a'
@@ -199,7 +200,30 @@ mod test {
     }
 
     #[test]
-    fn stores_and_unpack_works() {
+    fn stores_and_unpack_works_under_32() {
+        let mut chars_and_freq: HashMap<char, i32> = HashMap::new();
+        chars_and_freq.insert('a', 25);
+        chars_and_freq.insert('b', 14);
+        chars_and_freq.insert('c', 5);
+
+        let huff = Hufftree::new(chars_and_freq);
+        let canonical = CanonicalHufftree::from_tree(huff);
+
+        let input_text = String::from("abbcaa");
+
+        let mut virtual_buffer = Vec::new();
+        store_tree_and_text(canonical, &mut virtual_buffer, &input_text).unwrap();
+
+        // println!("Virtual buffer: {:?}", virtual_buffer);
+
+        let decoded_text = read_tree_and_text(&mut &virtual_buffer[0..virtual_buffer.len()]);
+
+        assert_eq!(decoded_text, input_text);
+        // println!("Decoded text: {}\nInput text:{}", decoded_text, input_text);
+    }
+
+    #[test]
+    fn stores_and_unpack_works_at_32() {
         let mut chars_and_freq: HashMap<char, i32> = HashMap::new();
         chars_and_freq.insert('a', 25);
         chars_and_freq.insert('b', 14);
@@ -208,7 +232,7 @@ mod test {
         let huff = Hufftree::new(chars_and_freq);
         let canonical = CanonicalHufftree::from_tree(huff);
 
-        let input_text = String::from("aacacacacabbbbbbbaaac");
+        let input_text = String::from("abbcaaaaaabababaacccba");
 
         let mut virtual_buffer = Vec::new();
         store_tree_and_text(canonical, &mut virtual_buffer, &input_text).unwrap();
@@ -220,4 +244,27 @@ mod test {
         assert_eq!(decoded_text, input_text);
         println!("Decoded text: {}\nInput text:{}", decoded_text, input_text);
     }
+
+    #[test]
+    fn stores_and_unpack_works_over_32() {
+        let mut chars_and_freq: HashMap<char, i32> = HashMap::new();
+        chars_and_freq.insert('a', 25);
+        chars_and_freq.insert('b', 14);
+        chars_and_freq.insert('c', 5);
+
+        let huff = Hufftree::new(chars_and_freq);
+        let canonical = CanonicalHufftree::from_tree(huff);
+
+        let input_text = String::from("aacacacacabbbbbbbacaaabaaa");
+
+        let mut virtual_buffer = Vec::new();
+        store_tree_and_text(canonical, &mut virtual_buffer, &input_text).unwrap();
+
+        // println!("Virtual buffer: {:?}", virtual_buffer);
+
+        let decoded_text = read_tree_and_text(&mut &virtual_buffer[0..virtual_buffer.len()]);
+
+        assert_eq!(decoded_text, input_text);
+        // println!("Decoded text: {}\nInput text:{}", decoded_text, input_text);
+    }
 }