chore: format code

src/client.rs

@@ -55,7 +55,11 @@ pub struct Client {
 }
 
 impl Client {
-    pub fn new(address: PeerAddress, username: String, password: String) -> Self {
+    pub fn new(
+        address: PeerAddress,
+        username: String,
+        password: String,
+    ) -> Self {
         crate::utils::logger::init();
         Self {
             address,
@@ -67,8 +71,10 @@ impl Client {
     }
 
     pub fn connect(&mut self) {
-        let (sender, message_reader): (Sender<ClientOperation>, Receiver<ClientOperation>) =
+        let (sender, message_reader): (
-            mpsc::channel();
+            Sender<ClientOperation>,
+            Receiver<ClientOperation>,
+        ) = mpsc::channel();
 
         self.context.lock().unwrap().sender = Some(sender.clone());
 
@@ -82,9 +88,13 @@ impl Client {
                 );
 
                 // Store the server sender in the client context
-                self.context.lock().unwrap().server_sender = Some(server.get_sender().clone());
+                self.context.lock().unwrap().server_sender =
+                    Some(server.get_sender().clone());
 
-                Self::listen_to_client_operations(message_reader, self.context.clone());
+                Self::listen_to_client_operations(
+                    message_reader,
+                    self.context.clone(),
+                );
                 Some(server)
             }
             Err(e) => {
@@ -123,7 +133,11 @@ impl Client {
         }
     }
 
-    pub fn search(&self, query: &str, timeout: Duration) -> Vec<FileSearchResult> {
+    pub fn search(
+        &self,
+        query: &str,
+        timeout: Duration,
+    ) -> Vec<FileSearchResult> {
         info!("Searching for {}", query);
         if let Some(server) = &self.server {
             let hash = md5::md5(query);
@@ -142,7 +156,11 @@ impl Client {
         return self.context.lock().unwrap().search_results.clone();
     }
 
-    pub fn download(&self, filename: String, username: String) -> crate::types::DownloadResult {
+    pub fn download(
+        &self,
+        filename: String,
+        username: String,
+    ) -> crate::types::DownloadResult {
         use crate::types::{DownloadResult, DownloadStatus};
         use std::time::{Duration, Instant};
 
@@ -243,7 +261,8 @@ impl Client {
                 let peer_clone = peer.clone();
                 let sender_clone = sender.clone();
                 unlocked_context.thread_pool.execute(move || {
-                    let default_peer = DefaultPeer::new(peer_clone, sender_clone);
+                    let default_peer =
+                        DefaultPeer::new(peer_clone, sender_clone);
                     match default_peer.connect() {
                         Ok(p) => {
                             let mut context = client_context.lock().unwrap();
@@ -272,9 +291,15 @@ impl Client {
         let context = client_context.lock().unwrap();
         if let Some(server_sender) = &context.server_sender {
             if let Some(token) = peer.token {
-                match server_sender.send(ServerOperation::PierceFirewall(token)) {
+                match server_sender.send(ServerOperation::PierceFirewall(token))
-                    Ok(_) => debug!("Sent PierceFirewall message with token: {}", token),
+                {
-                    Err(e) => error!("Failed to send PierceFirewall message: {}", e),
+                    Ok(_) => debug!(
+                        "Sent PierceFirewall message with token: {}",
+                        token
+                    ),
+                    Err(e) => {
+                        error!("Failed to send PierceFirewall message: {}", e)
+                    }
                 }
             } else {
                 error!("No token available for PierceFirewall");

src/lib.rs

@@ -22,4 +22,3 @@ pub use server::PeerAddress;
 pub use types::{
     DownloadResult, DownloadStatus, File, FileSearchResult, Transfer,
 };
-

src/message/message_reader.rs

@@ -41,7 +41,10 @@ impl MessageReader {
         }
     }
 
-    pub fn read_from_socket(&mut self, stream: &mut TcpStream) -> io::Result<()> {
+    pub fn read_from_socket(
+        &mut self,
+        stream: &mut TcpStream,
+    ) -> io::Result<()> {
         let mut temp_buffer = [0; 1024]; // Temporary buffer for reading from the socket
         let bytes_read = stream.read(&mut temp_buffer)?;
         if bytes_read == 0 {
@@ -85,10 +88,11 @@ mod tests {
     #[test]
     fn test_extract_message() {
         let buffer: Vec<u8> = [
-            8, 0, 0, 0, 117, 115, 101, 114, 110, 97, 109, 101, 8, 0, 0, 0, 112, 97, 115, 115, 119,
+            8, 0, 0, 0, 117, 115, 101, 114, 110, 97, 109, 101, 8, 0, 0, 0, 112,
-            111, 114, 100, 160, 0, 0, 0, 32, 0, 0, 0, 100, 53, 49, 99, 57, 97, 55, 101, 57, 51, 53,
+            97, 115, 115, 119, 111, 114, 100, 160, 0, 0, 0, 32, 0, 0, 0, 100,
-            51, 55, 52, 54, 97, 54, 48, 50, 48, 102, 57, 54, 48, 50, 100, 52, 53, 50, 57, 50, 57,
+            53, 49, 99, 57, 97, 55, 101, 57, 51, 53, 51, 55, 52, 54, 97, 54,
-            17, 0, 0, 0,
+            48, 50, 48, 102, 57, 54, 48, 50, 100, 52, 53, 50, 57, 50, 57, 17,
+            0, 0, 0,
         ]
         .to_vec();
         let mut buffered_reader = MessageReader::new_with_buffer(buffer);
@@ -102,7 +106,8 @@ mod tests {
     #[test]
     fn test_extract_message_incomplete_message() {
         let incomplete_buffer = vec![1, 2, 3];
-        let mut buffered_reader = MessageReader::new_with_buffer(incomplete_buffer);
+        let mut buffered_reader =
+            MessageReader::new_with_buffer(incomplete_buffer);
 
         let result = buffered_reader.extract_message();
         assert_eq!(None, result.unwrap());

src/message/mod.rs

@@ -6,7 +6,7 @@ pub mod peer;
 pub mod server;
 
 // Re-export commonly used items
-pub use handlers::{MessageHandler, Handlers};
+pub use handlers::{Handlers, MessageHandler};
 pub use message_reader::MessageReader;
 
 use std::str;
@@ -269,7 +269,8 @@ impl Message {
         let mut b = Vec::new();
         for i in (0..val.len()).step_by(2) {
             let byte_str = &val[i..i + 2];
-            let byte = u8::from_str_radix(byte_str, 16).expect("Invalid hex string");
+            let byte =
+                u8::from_str_radix(byte_str, 16).expect("Invalid hex string");
             b.push(byte);
         }
         self.data.extend_from_slice(&b);
@@ -277,7 +278,11 @@ impl Message {
         self
     }
 
-    pub fn get_message_name(&self, msg_type: MessageType, code: u32) -> Result<&str, Error> {
+    pub fn get_message_name(
+        &self,
+        msg_type: MessageType,
+        code: u32,
+    ) -> Result<&str, Error> {
         match msg_type {
             MessageType::Server => match code {
                 1 => Ok("Login"),
@@ -304,12 +309,17 @@ impl Message {
                 100 => Ok("AcceptChildren"),
                 102 => Ok("PossibleParents"),
                 1001 => Ok("CantConnectToPeer"),
-                _ => Err(Error(format!("Unknown server message code: {}", code))),
+                _ => {
+                    Err(Error(format!("Unknown server message code: {}", code)))
+                }
             },
             MessageType::PeerInit => match code {
                 0 => Ok("PierceFireWall"),
                 1 => Ok("PeerInit"),
-                _ => Err(Error(format!("Unknown peer init message code: {}", code))),
+                _ => Err(Error(format!(
+                    "Unknown peer init message code: {}",
+                    code
+                ))),
             },
             MessageType::Peer => match code {
                 4 => Ok("GetShareFileList"),
@@ -333,7 +343,10 @@ impl Message {
                 4 => Ok("BranchLevel"),
                 5 => Ok("BranchRoot"),
                 93 => Ok("EmbeddedMessage"),
-                _ => Err(Error(format!("Unknown distributed message code: {}", code))),
+                _ => Err(Error(format!(
+                    "Unknown distributed message code: {}",
+                    code
+                ))),
             },
         }
     }
@@ -346,37 +359,40 @@ impl Message {
 fn test_get_buffer() {
     let message = Message::new_with_data(
         [
-            26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104, 101, 32, 119, 101, 101, 107, 101,
+            26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104, 101, 32, 119,
-            110, 100,
+            101, 101, 107, 101, 110, 100,
         ]
         .to_vec(),
     );
     assert_eq!(
         message.get_buffer(),
         [
-            23, 0, 0, 0, 26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104, 101, 32, 119, 101,
+            23, 0, 0, 0, 26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104,
-            101, 107, 101, 110, 100,
+            101, 32, 119, 101, 101, 107, 101, 110, 100,
         ]
         .to_vec()
     );
 
     let message = Message::new_with_data(
         [
-            1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95, 116, 104, 101,
+            1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110,
-            95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51, 55, 53, 49, 51, 55, 160, 0, 0,
+            95, 116, 104, 101, 95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49,
-            0, 32, 0, 0, 0, 50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, 55, 56, 102,
+            51, 51, 55, 53, 49, 51, 55, 160, 0, 0, 0, 32, 0, 0, 0, 50, 101,
-            56, 98, 98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 17, 0, 0, 0,
+            100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, 55, 56, 102, 56, 98,
+            98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 17, 0, 0,
+            0,
         ]
         .to_vec(),
     );
     assert_eq!(
         message.get_buffer(),
         [
-            84, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95,
+            84, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101,
-            116, 104, 101, 95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51, 55, 53, 49, 51,
+            95, 105, 110, 95, 116, 104, 101, 95, 98, 114, 97, 105, 110, 50, 8,
-            55, 160, 0, 0, 0, 32, 0, 0, 0, 50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51,
+            0, 0, 0, 49, 51, 51, 55, 53, 49, 51, 55, 160, 0, 0, 0, 32, 0, 0, 0,
-            55, 56, 102, 56, 98, 98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 17, 0, 0,
+            50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, 55, 56,
-            0,
+            102, 56, 98, 98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98,
+            49, 17, 0, 0, 0,
         ]
         .to_vec()
     );
@@ -394,9 +410,9 @@ fn test_read_string() {
 #[test]
 fn test_read_string_2() {
     let data = vec![
-        50, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 81, 170, 162, 77, 32, 0, 0, 0, 101, 102, 99, 97,
+        50, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 81, 170, 162, 77, 32, 0, 0, 0,
-        51, 52, 102, 99, 52, 99, 56, 98, 101, 56, 98, 55, 101, 102, 51, 56, 97, 102, 50, 54, 50,
+        101, 102, 99, 97, 51, 52, 102, 99, 52, 99, 56, 98, 101, 56, 98, 55,
-        52, 100, 101, 53, 52, 54, 52, 0,
+        101, 102, 51, 56, 97, 102, 50, 54, 50, 52, 100, 101, 53, 52, 54, 52, 0,
     ];
     let mut test_data = Message::new_with_data(data);
     test_data.set_pointer(9);

src/message/peer/file_search_response.rs

@@ -20,18 +20,21 @@ impl MessageHandler<PeerOperation> for FileSearchResponse {
 #[test]
 fn test_new_from_message() {
     let data: Vec<u8> = [
-        229, 0, 0, 0, 9, 0, 0, 0, 120, 156, 99, 103, 96, 96, 72, 201, 79, 201, 76, 79, 204, 203,
+        229, 0, 0, 0, 9, 0, 0, 0, 120, 156, 99, 103, 96, 96, 72, 201, 79, 201,
-        213, 158, 98, 194, 4, 228, 50, 250, 3, 9, 7, 135, 162, 156, 148, 194, 188, 152, 228, 252,
+        76, 79, 204, 203, 213, 158, 98, 194, 4, 228, 50, 250, 3, 9, 7, 135,
-        220, 130, 156, 212, 146, 212, 24, 231, 196, 188, 228, 204, 252, 188, 212, 226, 152, 144,
+        162, 156, 148, 194, 188, 152, 228, 252, 220, 130, 156, 212, 146, 212,
-        162, 210, 226, 226, 212, 28, 93, 67, 75, 115, 75, 93, 119, 160, 144, 130, 91, 126, 145, 66,
+        24, 231, 196, 188, 228, 204, 252, 188, 212, 226, 152, 144, 162, 210,
-        72, 70, 170, 66, 120, 106, 106, 118, 106, 94, 138, 174, 161, 89, 82, 102, 137, 174, 137,
+        226, 226, 212, 28, 93, 67, 75, 115, 75, 93, 119, 160, 144, 130, 91,
-        137, 142, 161, 119, 70, 149, 94, 90, 78, 98, 114, 203, 175, 243, 32, 163, 193, 128, 25,
+        126, 145, 66, 72, 70, 170, 66, 120, 106, 106, 118, 106, 94, 138, 174,
-        100, 7, 16, 23, 0, 9, 22, 32, 237, 178, 134, 129, 129, 21, 72, 11, 128, 196, 243, 176, 217,
+        161, 89, 82, 102, 137, 174, 137, 137, 142, 161, 119, 70, 149, 94, 90,
-        29, 156, 153, 151, 158, 147, 90, 12, 54, 95, 193, 216, 84, 193, 200, 192, 200, 36, 198, 45,
+        78, 98, 114, 203, 175, 243, 32, 163, 193, 128, 25, 100, 7, 16, 23, 0,
-        181, 168, 40, 53, 57, 91, 193, 37, 177, 60, 79, 71, 193, 55, 177, 44, 181, 40, 19, 200, 13,
+        9, 22, 32, 237, 178, 134, 129, 129, 21, 72, 11, 128, 196, 243, 176,
-        78, 76, 42, 74, 85, 80, 83, 240, 75, 45, 7, 10, 38, 103, 100, 2, 221, 167, 139, 238, 66, 5,
+        217, 29, 156, 153, 151, 158, 147, 90, 12, 54, 95, 193, 216, 84, 193,
-        13, 144, 17, 154, 96, 167, 173, 228, 215, 98, 68, 119, 218, 74, 6, 76, 167, 49, 60, 153,
+        200, 192, 200, 36, 198, 45, 181, 168, 40, 53, 57, 91, 193, 37, 177, 60,
-        202, 200, 160, 199, 128, 0, 0, 161, 99, 76, 142,
+        79, 71, 193, 55, 177, 44, 181, 40, 19, 200, 13, 78, 76, 42, 74, 85, 80,
+        83, 240, 75, 45, 7, 10, 38, 103, 100, 2, 221, 167, 139, 238, 66, 5, 13,
+        144, 17, 154, 96, 167, 173, 228, 215, 98, 68, 119, 218, 74, 6, 76, 167,
+        49, 60, 153, 202, 200, 160, 199, 128, 0, 0, 161, 99, 76, 142,
     ]
     .to_vec();
     let mut message = Message::new_with_data(data);

src/message/server/connect_to_peer.rs

@@ -1,7 +1,7 @@
-use crate::trace;
 use crate::message::{Message, MessageHandler};
 use crate::peer::{ConnectionType, Peer};
 use crate::server::ServerOperation;
+use crate::trace;
 use std::sync::mpsc::Sender;
 pub struct ConnectToPeerHandler;
 impl MessageHandler<ServerOperation> for ConnectToPeerHandler {

src/message/server/file_search.rs

@@ -1,9 +1,9 @@
 use crate::{debug, info};
 use std::sync::mpsc::Sender;
 
-use crate::{message::handlers::MessageHandler,
+use crate::{
+    message::handlers::MessageHandler, message::Message,
     server::ServerOperation,
-    message::Message
 };
 
 pub struct FileSearchHandler;

src/message/server/message_factory.rs

@@ -1,4 +1,6 @@
-use crate::{message::Message, peer::ConnectionType, types::Transfer, utils::md5::md5};
+use crate::{
+    message::Message, peer::ConnectionType, types::Transfer, utils::md5::md5,
+};
 
 pub struct MessageFactory;
 impl MessageFactory {
@@ -34,7 +36,10 @@ impl MessageFactory {
         message
     }
 
-    pub fn build_shared_folders_message(folder_count: u32, file_count: u32) -> Message {
+    pub fn build_shared_folders_message(
+        folder_count: u32,
+        file_count: u32,
+    ) -> Message {
         Message::new()
             .write_int32(35)
             .write_int32(folder_count)
@@ -121,13 +126,15 @@ fn test_build_watch_user() {
 
 #[test]
 fn test_build_login_message() {
-    let message = MessageFactory::build_login_message("insane_in_the_brain2", "13375137");
+    let message =
+        MessageFactory::build_login_message("insane_in_the_brain2", "13375137");
 
     let expect: Vec<u8> = [
-        1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95, 116, 104, 101, 95,
+        1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95,
-        98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51, 55, 53, 49, 51, 55, 157, 0, 0, 0, 32, 0,
+        116, 104, 101, 95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51,
-        0, 0, 50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, 55, 56, 102, 56, 98, 98, 54,
+        55, 53, 49, 51, 55, 157, 0, 0, 0, 32, 0, 0, 0, 50, 101, 100, 102, 53,
-        51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 100, 0, 0, 0,
+        49, 100, 48, 51, 55, 57, 52, 51, 55, 56, 102, 56, 98, 98, 54, 51, 49,
+        48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 100, 0, 0, 0,
     ]
     .to_vec();
 
@@ -140,7 +147,8 @@ fn test_build_login_message() {
 fn test_build_file_search_message() {
     let message = MessageFactory::build_file_search_message(12, "trance wax");
     let expect: Vec<u8> = [
-        26, 0, 0, 0, 12, 0, 0, 0, 10, 0, 0, 0, 116, 114, 97, 110, 99, 101, 32, 119, 97, 120,
+        26, 0, 0, 0, 12, 0, 0, 0, 10, 0, 0, 0, 116, 114, 97, 110, 99, 101, 32,
+        119, 97, 120,
     ]
     .to_vec();
     assert_eq!(expect, message.get_data())

src/message/server/mod.rs

@@ -22,4 +22,3 @@ pub use parent_speed_ratio::ParentSpeedRatioHandler;
 pub use privileged_users::PrivilegedUsersHandler;
 pub use room_list::RoomListHandler;
 pub use wish_list_interval::WishListIntervalHandler;
-

src/message/server/parent_min_speed.rs

@@ -1,4 +1,3 @@
-
 use crate::debug;
 use std::sync::mpsc::Sender;
 

src/message/server/parent_speed_ratio.rs

@@ -1,4 +1,3 @@
-
 use crate::debug;
 use std::sync::mpsc::Sender;
 

src/message/server/privileged_users.rs

@@ -1,4 +1,3 @@
-
 use crate::debug;
 use std::sync::mpsc::Sender;
 

src/message/server/wish_list_interval.rs

@@ -1,4 +1,3 @@
-
 use crate::debug;
 use std::sync::mpsc::Sender;
 

src/peer/default_peer.rs

@@ -1,6 +1,8 @@
 use crate::dispatcher::MessageDispatcher;
-use crate::message::peer::{GetShareFileList, TransferRequest, UploadFailedHandler};
 use crate::message::peer::FileSearchResponse;
+use crate::message::peer::{
+    GetShareFileList, TransferRequest, UploadFailedHandler,
+};
 use crate::message::server::MessageFactory;
 use crate::message::{Handlers, Message, MessageReader, MessageType};
 use crate::types::{FileSearchResult, Transfer};
@@ -9,16 +11,14 @@ use std::sync::mpsc;
 use std::sync::mpsc::{Receiver, Sender};
 use std::thread::{self, JoinHandle};
 
-use crate::{debug, error, trace, warn};
 use crate::client::ClientOperation;
 use crate::peer::Peer;
+use crate::{debug, error, trace, warn};
 use std::io::{self, Write};
 use std::net::TcpStream;
 use std::net::ToSocketAddrs;
 use std::time::Duration;
 
-
-
 #[allow(dead_code)]
 pub struct DefaultPeer {
     peer: Peer,
@@ -48,9 +48,14 @@ impl DefaultPeer {
         let socket_address = format!("{}:{}", self.peer.host, self.peer.port)
             .to_socket_addrs()?
             .next()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Invalid address"))?;
+            .ok_or_else(|| {
+                io::Error::new(io::ErrorKind::InvalidInput, "Invalid address")
+            })?;
 
-        let mut stream = TcpStream::connect_timeout(&socket_address, Duration::from_secs(20))?;
+        let mut stream = TcpStream::connect_timeout(
+            &socket_address,
+            Duration::from_secs(20),
+        )?;
 
         stream.set_read_timeout(Some(Duration::from_secs(5)))?;
         stream.set_write_timeout(Some(Duration::from_secs(5)))?;
@@ -65,9 +70,14 @@ impl DefaultPeer {
         Ok(self)
     }
 
-    fn start_read_write_loops(&mut self, stream: TcpStream) -> Result<(), io::Error> {
+    fn start_read_write_loops(
-        let (peer_sender, peer_reader): (Sender<PeerOperation>, Receiver<PeerOperation>) =
+        &mut self,
-            mpsc::channel();
+        stream: TcpStream,
+    ) -> Result<(), io::Error> {
+        let (peer_sender, peer_reader): (
+            Sender<PeerOperation>,
+            Receiver<PeerOperation>,
+        ) = mpsc::channel();
 
         // Set the peer_channel so transfer_request can send messages
         self.peer_channel = Some(peer_sender.clone());
@@ -92,7 +102,9 @@ impl DefaultPeer {
             loop {
                 match buffered_reader.read_from_socket(&mut read_stream) {
                     Ok(_) => {}
-                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                        continue
+                    }
                     Err(ref e) if e.kind() == io::ErrorKind::TimedOut => {
                         debug!(
                             "Read operation timed out in default peer {:}:{:}",
@@ -102,8 +114,11 @@ impl DefaultPeer {
                     }
                     Err(e) => {
                         error!("Error reading from peer: {}. Terminating read loop.", e);
-                        let _ = client_channel_for_read
+                        let _ = client_channel_for_read.send(
-                            .send(ClientOperation::PeerDisconnected(peer.username.clone()));
+                            ClientOperation::PeerDisconnected(
+                                peer.username.clone(),
+                            ),
+                        );
                         break;
                     }
                 }
@@ -127,8 +142,11 @@ impl DefaultPeer {
                             "Error extracting message in default peer: {}. Terminating read loop.",
                             e
                         );
-                        let _ = client_channel_for_read
+                        let _ = client_channel_for_read.send(
-                            .send(ClientOperation::PeerDisconnected(peer.username.clone()));
+                            ClientOperation::PeerDisconnected(
+                                peer.username.clone(),
+                            ),
+                        );
                         break;
                     }
                     Ok(None) => continue,
@@ -143,7 +161,8 @@ impl DefaultPeer {
         self.write_thread = Some(thread::spawn(move || {
             loop {
                 match peer_reader.recv() {
-                    Ok(operation) => match operation {
+                    Ok(operation) => {
+                        match operation {
                             PeerOperation::SendMessage(message) => {
                                 trace!(
                                     "[default_peer:{:?}] ➡ {:?} - {:?}",
@@ -152,23 +171,33 @@ impl DefaultPeer {
                                         .get_message_name(
                                             MessageType::Peer,
                                             u32::from_le_bytes(
-                                            message.get_slice(0, 4).try_into().unwrap()
+                                                message
+                                                    .get_slice(0, 4)
+                                                    .try_into()
+                                                    .unwrap()
                                             )
                                         )
                                         .map_err(|e| e.to_string()),
                                     message
                                 );
 
-                            if let Err(e) = write_stream.write_all(&message.get_buffer()) {
+                                if let Err(e) = write_stream
+                                    .write_all(&message.get_buffer())
+                                {
                                     error!("Error writing message to stream: {} - {}. Terminating write loop.", peer_username, e);
-                                let _ = client_channel
+                                    let _ = client_channel.send(
-                                    .send(ClientOperation::PeerDisconnected(peer_username.clone()));
+                                        ClientOperation::PeerDisconnected(
+                                            peer_username.clone(),
+                                        ),
+                                    );
                                     break;
                                 }
                             }
                             PeerOperation::FileSearchResult(file_search) => {
                                 client_channel
-                                .send(ClientOperation::SearchResult(file_search))
+                                    .send(ClientOperation::SearchResult(
+                                        file_search,
+                                    ))
                                     .unwrap();
                             }
                             PeerOperation::TransferRequest(transfer) => {
@@ -177,7 +206,9 @@ impl DefaultPeer {
                                     peer_username, transfer
                                 );
                                 client_channel
-                                .send(ClientOperation::TransferRequest(transfer.clone()))
+                                    .send(ClientOperation::TransferRequest(
+                                        transfer.clone(),
+                                    ))
                                     .unwrap();
 
                                 let transfer_response =
@@ -185,11 +216,14 @@ impl DefaultPeer {
 
                                 if let Some(sender) = peer_channel.clone() {
                                     sender
-                                    .send(PeerOperation::SendMessage(transfer_response))
+                                        .send(PeerOperation::SendMessage(
+                                            transfer_response,
+                                        ))
                                         .unwrap();
                                 }
                             }
-                    },
+                        }
+                    }
                     Err(_) => {
                         // The sender has been dropped, the peer is shutting down.
                         debug!("Peer channel closed. Terminating write loop.");

src/peer/listen.rs

@@ -19,8 +19,12 @@ impl Listen {
             loop {
                 match buffered_reader.read_from_socket(&mut read_stream) {
                     Ok(_) => {}
-                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                        continue
+                    }
+                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                        continue
+                    }
                     Err(ref e) if e.kind() == io::ErrorKind::TimedOut => {
                         debug!("Read operation timed out");
                         continue;
@@ -33,7 +37,10 @@ impl Listen {
 
                 match buffered_reader.extract_message() {
                     Ok(Some(mut message)) => {
-                        debug!("Received message: {:?}", message.get_message_code());
+                        debug!(
+                            "Received message: {:?}",
+                            message.get_message_code()
+                        );
                         trace!("{:?}", message.get_data());
                         message.print_hex();
 

src/peer/mod.rs

@@ -128,8 +128,8 @@ impl Peer {
 #[test]
 fn test_new_from_message() {
     let data: Vec<u8> = [
-        36, 0, 0, 0, 18, 0, 0, 0, 2, 0, 0, 0, 100, 112, 1, 0, 0, 0, 80, 27, 231, 37, 45, 186, 8, 0,
+        36, 0, 0, 0, 18, 0, 0, 0, 2, 0, 0, 0, 100, 112, 1, 0, 0, 0, 80, 27,
-        0, 178, 78, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        231, 37, 45, 186, 8, 0, 0, 178, 78, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ]
     .to_vec();
     let mut message = Message::new_with_data(data);
@@ -150,8 +150,9 @@ fn test_new_from_message() {
 #[test]
 fn test_new_from_message2() {
     let data: Vec<u8> = [
-        42, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 0, 103, 114, 97, 110, 100, 112, 97, 103, 1, 0, 0, 0, 80,
+        42, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 0, 103, 114, 97, 110, 100, 112, 97,
-        137, 128, 193, 68, 187, 8, 0, 0, 58, 16, 0, 0, 0, 1, 0, 0, 0, 188, 8, 0, 0,
+        103, 1, 0, 0, 0, 80, 137, 128, 193, 68, 187, 8, 0, 0, 58, 16, 0, 0, 0,
+        1, 0, 0, 0, 188, 8, 0, 0,
     ]
     .to_vec();
     let mut message = Message::new_with_data(data);

src/server.rs

@@ -14,7 +14,7 @@ use crate::message::server::WishListIntervalHandler;
 use crate::message::Handlers;
 use crate::message::Message;
 use crate::message::MessageReader;
-use crate::peer::{listen::Listen};
+use crate::peer::listen::Listen;
 use crate::peer::ConnectionType;
 use crate::peer::Peer;
 
@@ -28,7 +28,6 @@ use std::time::{Duration, Instant};
 
 use crate::{debug, error, info, warn};
 
-
 #[derive(Debug, Clone)]
 pub struct PeerAddress {
     host: String,
@@ -100,7 +99,11 @@ impl UserMessage {
     pub fn print(&self) {
         debug!(
             "Timestamp: {}. User: {}, Id: #{}, New message: {} Message: {}",
-            self.timestamp, self.username, self.id, self.new_message, self.message
+            self.timestamp,
+            self.username,
+            self.id,
+            self.new_message,
+            self.message
         );
     }
 }
@@ -191,8 +194,10 @@ impl Server {
         address: PeerAddress,
         client_channel: Sender<ClientOperation>,
     ) -> Result<Self, io::Error> {
-        let (sender, server_channel): (Sender<ServerOperation>, Receiver<ServerOperation>) =
+        let (sender, server_channel): (
-            mpsc::channel();
+            Sender<ServerOperation>,
+            Receiver<ServerOperation>,
+        ) = mpsc::channel();
 
         let context = Arc::new(Mutex::new(Context::new()));
 
@@ -220,17 +225,26 @@ impl Server {
         server_channel: Receiver<ServerOperation>,
         client_channel: Sender<ClientOperation>,
     ) -> Result<(), io::Error> {
-        let socket_address = format!("{}:{}", self.address.host, self.address.port)
+        let socket_address =
+            format!("{}:{}", self.address.host, self.address.port)
                 .to_socket_addrs()?
                 .next()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Invalid address"))?;
+                .ok_or_else(|| {
+                    io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "Invalid address",
+                    )
+                })?;
 
         info!(
             "Connecting to server at {}:{}",
             self.address.host, self.address.port
         );
 
-        let stream = TcpStream::connect_timeout(&socket_address, Duration::from_secs(10))?;
+        let stream = TcpStream::connect_timeout(
+            &socket_address,
+            Duration::from_secs(10),
+        )?;
 
         stream.set_read_timeout(Some(Duration::from_secs(5)))?;
         stream.set_write_timeout(Some(Duration::from_secs(5)))?;
@@ -267,8 +281,12 @@ impl Server {
             loop {
                 match buffered_reader.read_from_socket(&mut read_stream) {
                     Ok(_) => {}
-                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                        continue
+                    }
+                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                        continue
+                    }
                     Err(ref e) if e.kind() == io::ErrorKind::TimedOut => {
                         debug!("Read operation timed out");
                         continue;
@@ -311,15 +329,20 @@ impl Server {
             loop {
                 if let Ok(operation) = server_channel.recv() {
                     match operation {
-                        ServerOperation::ConnectToPeer(peer) => match peer.connection_type {
+                        ServerOperation::ConnectToPeer(peer) => {
+                            match peer.connection_type {
                                 ConnectionType::P => {
-                                match client_channel.send(ClientOperation::ConnectToPeer(peer)) {
+                                    match client_channel.send(
+                                        ClientOperation::ConnectToPeer(peer),
+                                    ) {
                                         Ok(_) => {}
                                         Err(_e) => {}
                                     }
                                 }
                                 ConnectionType::F => {
-                                match client_channel.send(ClientOperation::PierceFireWall(peer)) {
+                                    match client_channel.send(
+                                        ClientOperation::PierceFireWall(peer),
+                                    ) {
                                         Ok(_) => {
                                             debug!("Sent PierceFireWall operation for F-type connection");
                                         }
@@ -329,13 +352,19 @@ impl Server {
                                     }
                                 }
                                 ConnectionType::D => {}
-                        },
+                            }
+                        }
                         ServerOperation::LoginStatus(message) => {
                             context.lock().unwrap().logged_in = Some(message);
                         }
                         ServerOperation::PierceFirewall(token) => {
-                            let pierce_message = MessageFactory::build_pierce_firewall_message(token);
+                            let pierce_message =
-                            match write_stream.write_all(&pierce_message.get_buffer()) {
+                                MessageFactory::build_pierce_firewall_message(
+                                    token,
+                                );
+                            match write_stream
+                                .write_all(&pierce_message.get_buffer())
+                            {
                                 Ok(_) => {
                                     debug!("Sent PierceFirewall message with token: {}", token);
                                 }
@@ -357,10 +386,14 @@ impl Server {
                             //         )
                             //         .map_err(|e| e.to_string()),
                             // );
-                            match write_stream.write_all(&message.get_buffer()) {
+                            match write_stream.write_all(&message.get_buffer())
+                            {
                                 Ok(_) => {}
                                 Err(e) => {
-                                    error!("Error writing message to stream : {}", e);
+                                    error!(
+                                        "Error writing message to stream : {}",
+                                        e
+                                    );
                                     break;
                                 }
                             }
@@ -383,10 +416,16 @@ impl Server {
         thread::spawn(move || Listen::start(2234, server_channel));
     }
 
-    pub fn login(&self, username: &str, password: &str) -> Result<bool, std::io::Error> {
+    pub fn login(
+        &self,
+        username: &str,
+        password: &str,
+    ) -> Result<bool, std::io::Error> {
         self.start_listener(self.sender.clone());
         // Send the login message
-        self.queue_message(MessageFactory::build_login_message(username, password));
+        self.queue_message(MessageFactory::build_login_message(
+            username, password,
+        ));
         let context = self.context.clone();
         let mut logged_in;
         let timeout = Duration::from_secs(5);
@@ -414,7 +453,9 @@ impl Server {
         if logged_in.unwrap() {
             info!("Logged in as {}", username);
             self.queue_message(MessageFactory::build_set_wait_port_message());
-            self.queue_message(MessageFactory::build_shared_folders_message(1, 499));
+            self.queue_message(MessageFactory::build_shared_folders_message(
+                1, 499,
+            ));
             self.queue_message(MessageFactory::build_no_parent_message());
             self.queue_message(MessageFactory::build_set_status_message(2));
         }
@@ -423,7 +464,9 @@ impl Server {
     }
 
     pub fn file_search(&self, token: u32, query: &str) {
-        self.queue_message(MessageFactory::build_file_search_message(token, query));
+        self.queue_message(MessageFactory::build_file_search_message(
+            token, query,
+        ));
     }
 
     #[allow(dead_code)]

src/utils/logger.rs

@@ -59,7 +59,8 @@ pub fn log(level: LogLevel, message: &str) {
             let mut remaining_days = days_since_1970;
 
             while remaining_days >= 365 {
-                let is_leap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
+                let is_leap =
+                    (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
                 let days_in_year = if is_leap { 366 } else { 365 };
                 if remaining_days >= days_in_year {
                     remaining_days -= days_in_year;
@@ -71,12 +72,17 @@ pub fn log(level: LogLevel, message: &str) {
 
             // Calculate month and day (simplified)
             let month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-            let is_leap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
+            let is_leap =
+                (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
             let mut month = 1;
             let mut day = remaining_days + 1;
 
             for &days_in_month in &month_days {
-                let actual_days = if month == 2 && is_leap { 29 } else { days_in_month };
+                let actual_days = if month == 2 && is_leap {
+                    29
+                } else {
+                    days_in_month
+                };
                 if day > actual_days {
                     day -= actual_days;
                     month += 1;
@@ -91,8 +97,18 @@ pub fn log(level: LogLevel, message: &str) {
             let minutes = (seconds_in_day % 3600) / 60;
             let seconds = seconds_in_day % 60;
 
-            eprintln!("[{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}] [{}] {}", 
+            eprintln!(
-                year, month, day, hours, minutes, seconds, subsec_millis, level_str, message);
+                "[{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}] [{}] {}",
+                year,
+                month,
+                day,
+                hours,
+                minutes,
+                seconds,
+                subsec_millis,
+                level_str,
+                message
+            );
         }
     }
 }

src/utils/md5.rs

@@ -54,8 +54,9 @@ fn i(x: u32, y: u32, z: u32) -> u32 {
 
 // utility function to convert a vector of type T with size N into an array of type T with size N.
 fn vec_to_array<T, const N: usize>(v: Vec<T>) -> [T; N] {
-    v.try_into()
+    v.try_into().unwrap_or_else(|_v: Vec<T>| {
-        .unwrap_or_else(|_v: Vec<T>| panic!("error converting vector to array - sizes don't match"))
+        panic!("error converting vector to array - sizes don't match")
+    })
 }
 
 /**
@@ -297,14 +298,16 @@ fn compute_md5_digest(mut v: Vec<u8>) -> String {
         let word_dd = word_d;
 
         // execute round 1
-        let result = round_one_operations(word_a, word_b, word_c, word_d, &table, &x);
+        let result =
+            round_one_operations(word_a, word_b, word_c, word_d, &table, &x);
         word_a = result[0];
         word_b = result[1];
         word_c = result[2];
         word_d = result[3];
 
         // execute round 2
-        let result = round_two_operations(word_a, word_b, word_c, word_d, &table, &x);
+        let result =
+            round_two_operations(word_a, word_b, word_c, word_d, &table, &x);
 
         word_a = result[0];
         word_b = result[1];
@@ -312,14 +315,16 @@ fn compute_md5_digest(mut v: Vec<u8>) -> String {
         word_d = result[3];
 
         // execute round 3
-        let result = round_three_operations(word_a, word_b, word_c, word_d, &table, &x);
+        let result =
+            round_three_operations(word_a, word_b, word_c, word_d, &table, &x);
         word_a = result[0];
         word_b = result[1];
         word_c = result[2];
         word_d = result[3];
 
         // execute round 4
-        let result = round_four_operations(word_a, word_b, word_c, word_d, &table, &x);
+        let result =
+            round_four_operations(word_a, word_b, word_c, word_d, &table, &x);
         word_a = result[0];
         word_b = result[1];
         word_c = result[2];
@@ -374,7 +379,6 @@ fn bit_padding(input: &str) -> Vec<u8> {
 }
 
 fn split_u64_to_u8_array(s: u64) -> [u8; 8] {
-    
     [
         s as u8,
         (s >> 8) as u8,
@@ -455,7 +459,8 @@ fn lowercase_alphabet_correct_hash() {
 
 #[test]
 fn all_alphanumeric_correct_hash() {
-    let alpha_num_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let alpha_num_str =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 
     assert_eq!("d174ab98d277d9f5a5611c2c9f419d9f", md5(alpha_num_str));
 }

src/utils/zlib.rs

@@ -98,7 +98,10 @@ fn inflate(r: &mut BitReader) -> Result<Vec<u8>, String> {
     Ok(out)
 }
 
-fn inflate_block_no_compression(r: &mut BitReader, o: &mut Vec<u8>) -> Result<(), String> {
+fn inflate_block_no_compression(
+    r: &mut BitReader,
+    o: &mut Vec<u8>,
+) -> Result<(), String> {
     let len = r.read_bytes(2)?;
     let _nlen = r.read_bytes(2)?;
     for _ in 0..len {
@@ -168,19 +171,20 @@ fn decode_symbol(r: &mut BitReader, t: &HuffmanTree) -> Result<u32, String> {
 }
 
 const LENGTH_EXTRA_BITS: [usize; 29] = [
-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5,
+    5, 5, 5, 0,
 ];
 const LENGTH_BASE: [u32; 29] = [
-    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131,
+    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
-    163, 195, 227, 258,
+    67, 83, 99, 115, 131, 163, 195, 227, 258,
 ];
 const DISTANCE_EXTRA_BITS: [usize; 30] = [
-    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13,
+    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
-    13,
+    11, 11, 12, 12, 13, 13,
 ];
 const DISTANCE_BASE: [u32; 30] = [
-    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537,
+    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
-    2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577,
+    769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577,
 ];
 
 fn inflate_block_data(
@@ -203,7 +207,8 @@ fn inflate_block_data(
             if sym_idx >= LENGTH_EXTRA_BITS.len() {
                 return Err("Invalid length symbol".to_string());
             }
-            let length = r.read_bits(LENGTH_EXTRA_BITS[sym_idx])? + LENGTH_BASE[sym_idx];
+            let length =
+                r.read_bits(LENGTH_EXTRA_BITS[sym_idx])? + LENGTH_BASE[sym_idx];
             let dist_sym = decode_symbol(r, distance_tree)?;
             if dist_sym as usize >= DISTANCE_EXTRA_BITS.len() {
                 return Err("Invalid distance symbol".to_string());
@@ -250,7 +255,9 @@ const CODE_LENGTH_CODES_ORDER: [usize; 19] = [
     16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15,
 ];
 
-fn decode_trees(r: &mut BitReader) -> Result<(HuffmanTree, HuffmanTree), String> {
+fn decode_trees(
+    r: &mut BitReader,
+) -> Result<(HuffmanTree, HuffmanTree), String> {
     // The number of literal/length codes
     let hlit = r.read_bits(5)? + 257;
 
@@ -263,12 +270,14 @@ fn decode_trees(r: &mut BitReader) -> Result<(HuffmanTree, HuffmanTree), String>
     // Read code lengths for the code length alphabet
     let mut code_length_tree_bl = vec![0; 19];
     for i in 0..hclen as usize {
-        code_length_tree_bl[CODE_LENGTH_CODES_ORDER[i]] = r.read_bits(3)? as usize;
+        code_length_tree_bl[CODE_LENGTH_CODES_ORDER[i]] =
+            r.read_bits(3)? as usize;
     }
 
     // Construct code length tree
     let code_length_alphabet: Vec<u32> = (0..19).collect();
-    let code_length_tree = bl_list_to_tree(&code_length_tree_bl, &code_length_alphabet);
+    let code_length_tree =
+        bl_list_to_tree(&code_length_tree_bl, &code_length_alphabet);
 
     // Read literal/length + distance code length list
     let mut bl = Vec::new();
@@ -303,20 +312,28 @@ fn decode_trees(r: &mut BitReader) -> Result<(HuffmanTree, HuffmanTree), String>
 
     // Construct trees
     let literal_length_alphabet: Vec<u32> = (0..286).collect();
-    let literal_length_tree = bl_list_to_tree(&bl[..hlit as usize], &literal_length_alphabet);
+    let literal_length_tree =
+        bl_list_to_tree(&bl[..hlit as usize], &literal_length_alphabet);
 
     let distance_alphabet: Vec<u32> = (0..30).collect();
-    let distance_tree = bl_list_to_tree(&bl[hlit as usize..], &distance_alphabet);
+    let distance_tree =
+        bl_list_to_tree(&bl[hlit as usize..], &distance_alphabet);
 
     Ok((literal_length_tree, distance_tree))
 }
 
-fn inflate_block_dynamic(r: &mut BitReader, o: &mut Vec<u8>) -> Result<(), String> {
+fn inflate_block_dynamic(
+    r: &mut BitReader,
+    o: &mut Vec<u8>,
+) -> Result<(), String> {
     let (literal_length_tree, distance_tree) = decode_trees(r)?;
     inflate_block_data(r, &literal_length_tree, &distance_tree, o)
 }
 
-fn inflate_block_fixed(r: &mut BitReader, o: &mut Vec<u8>) -> Result<(), String> {
+fn inflate_block_fixed(
+    r: &mut BitReader,
+    o: &mut Vec<u8>,
+) -> Result<(), String> {
     let mut bl = Vec::new();
     bl.extend(vec![8; 144]); // 0-143: 8 bits
     bl.extend(vec![9; 112]); // 144-255: 9 bits
@@ -377,7 +394,8 @@ mod tests {
     fn test_deflate() {
         // Test data from the original test - this should work with our new implementation
         let data = vec![
-            120, 156, 203, 72, 205, 201, 201, 87, 8, 207, 47, 202, 73, 1, 0, 24, 11, 4, 93,
+            120, 156, 203, 72, 205, 201, 201, 87, 8, 207, 47, 202, 73, 1, 0,
+            24, 11, 4, 93,
         ];
         let result = deflate(&data);
         assert!(result.is_ok());
@@ -388,35 +406,44 @@ mod tests {
     #[test]
     fn test_deflate2() {
         let data = vec![
-            120, 156, 99, 103, 96, 96, 72, 201, 79, 201, 76, 79, 204, 203, 213, 158, 98, 194, 4,
+            120, 156, 99, 103, 96, 96, 72, 201, 79, 201, 76, 79, 204, 203, 213,
-            228, 50, 250, 3, 9, 7, 135, 162, 156, 148, 194, 188, 152, 228, 252, 220, 130, 156, 212,
+            158, 98, 194, 4, 228, 50, 250, 3, 9, 7, 135, 162, 156, 148, 194,
-            146, 212, 24, 231, 196, 188, 228, 204, 252, 188, 212, 226, 152, 144, 162, 210, 226,
+            188, 152, 228, 252, 220, 130, 156, 212, 146, 212, 24, 231, 196,
-            226, 212, 28, 93, 67, 75, 115, 75, 93, 119, 160, 144, 130, 91, 126, 145, 66, 72, 70,
+            188, 228, 204, 252, 188, 212, 226, 152, 144, 162, 210, 226, 226,
-            170, 66, 120, 106, 106, 118, 106, 94, 138, 174, 161, 89, 82, 102, 137, 174, 137, 137,
+            212, 28, 93, 67, 75, 115, 75, 93, 119, 160, 144, 130, 91, 126, 145,
-            142, 161, 119, 70, 149, 94, 90, 78, 98, 114, 203, 175, 243, 32, 163, 193, 128, 25, 100,
+            66, 72, 70, 170, 66, 120, 106, 106, 118, 106, 94, 138, 174, 161,
-            7, 16, 23, 0, 9, 22, 32, 237, 178, 134, 129, 129, 21, 72, 11, 128, 196, 243, 176, 217,
+            89, 82, 102, 137, 174, 137, 137, 142, 161, 119, 70, 149, 94, 90,
-            29, 156, 153, 151, 158, 147, 90, 12, 54, 95, 193, 216, 84, 193, 200, 192, 200, 36, 198,
+            78, 98, 114, 203, 175, 243, 32, 163, 193, 128, 25, 100, 7, 16, 23,
-            45, 181, 168, 40, 53, 57, 91, 193, 37, 177, 60, 79, 71, 193, 55, 177, 44, 181, 40, 19,
+            0, 9, 22, 32, 237, 178, 134, 129, 129, 21, 72, 11, 128, 196, 243,
-            200, 13, 78, 76, 42, 74, 85, 80, 83, 240, 75, 45, 7, 10, 38, 103, 100, 2, 221, 167,
+            176, 217, 29, 156, 153, 151, 158, 147, 90, 12, 54, 95, 193, 216,
-            139, 238, 66, 5, 13, 144, 17, 154, 96, 167, 173, 228, 215, 98, 68, 119, 218, 74, 6, 76,
+            84, 193, 200, 192, 200, 36, 198, 45, 181, 168, 40, 53, 57, 91, 193,
-            167, 49, 60, 153, 202, 200, 160, 199, 128, 0, 0, 161, 99, 76, 142,
+            37, 177, 60, 79, 71, 193, 55, 177, 44, 181, 40, 19, 200, 13, 78,
+            76, 42, 74, 85, 80, 83, 240, 75, 45, 7, 10, 38, 103, 100, 2, 221,
+            167, 139, 238, 66, 5, 13, 144, 17, 154, 96, 167, 173, 228, 215, 98,
+            68, 119, 218, 74, 6, 76, 167, 49, 60, 153, 202, 200, 160, 199, 128,
+            0, 0, 161, 99, 76, 142,
         ];
         let expect = vec![
-            7, 0, 0, 0, 100, 111, 100, 105, 103, 97, 110, 109, 43, 148, 52, 2, 0, 0, 0, 1, 79, 0,
+            7, 0, 0, 0, 100, 111, 100, 105, 103, 97, 110, 109, 43, 148, 52, 2,
-            0, 0, 64, 64, 114, 108, 100, 113, 110, 92, 99, 111, 109, 112, 108, 101, 116, 101, 92,
+            0, 0, 0, 1, 79, 0, 0, 0, 64, 64, 114, 108, 100, 113, 110, 92, 99,
-            67, 97, 110, 99, 105, 111, 110, 101, 115, 92, 84, 114, 117, 115, 115, 101, 108, 45, 49,
+            111, 109, 112, 108, 101, 116, 101, 92, 67, 97, 110, 99, 105, 111,
-            57, 55, 57, 45, 71, 111, 110, 101, 32, 70, 111, 114, 32, 84, 104, 101, 32, 87, 101,
+            110, 101, 115, 92, 84, 114, 117, 115, 115, 101, 108, 45, 49, 57,
-            101, 107, 101, 110, 100, 45, 49, 54, 98, 105, 116, 45, 52, 52, 44, 49, 75, 104, 122,
+            55, 57, 45, 71, 111, 110, 101, 32, 70, 111, 114, 32, 84, 104, 101,
-            46, 102, 108, 97, 99, 132, 250, 207, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0,
+            32, 87, 101, 101, 107, 101, 110, 100, 45, 49, 54, 98, 105, 116, 45,
-            112, 1, 0, 0, 4, 0, 0, 0, 68, 172, 0, 0, 5, 0, 0, 0, 16, 0, 0, 0, 1, 110, 0, 0, 0, 64,
+            52, 52, 44, 49, 75, 104, 122, 46, 102, 108, 97, 99, 132, 250, 207,
-            64, 114, 108, 100, 113, 110, 92, 99, 111, 109, 112, 108, 101, 116, 101, 92, 83, 105,
+            2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 112, 1, 0, 0, 4,
-            110, 103, 108, 101, 115, 32, 87, 101, 101, 107, 32, 51, 53, 32, 50, 48, 50, 52, 92, 70,
+            0, 0, 0, 68, 172, 0, 0, 5, 0, 0, 0, 16, 0, 0, 0, 1, 110, 0, 0, 0,
-            101, 114, 114, 101, 99, 107, 32, 68, 97, 119, 110, 44, 32, 77, 97, 118, 101, 114, 105,
+            64, 64, 114, 108, 100, 113, 110, 92, 99, 111, 109, 112, 108, 101,
-            99, 107, 32, 83, 97, 98, 114, 101, 32, 38, 32, 78, 101, 119, 32, 77, 97, 99, 104, 105,
+            116, 101, 92, 83, 105, 110, 103, 108, 101, 115, 32, 87, 101, 101,
-            110, 101, 32, 45, 32, 70, 111, 114, 32, 84, 104, 101, 32, 87, 101, 101, 107, 101, 110,
+            107, 32, 51, 53, 32, 50, 48, 50, 52, 92, 70, 101, 114, 114, 101,
-            100, 32, 40, 50, 48, 50, 52, 41, 46, 102, 108, 97, 99, 169, 15, 42, 1, 0, 0, 0, 0, 0,
+            99, 107, 32, 68, 97, 119, 110, 44, 32, 77, 97, 118, 101, 114, 105,
-            0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 169, 0, 0, 0, 4, 0, 0, 0, 68, 172, 0, 0, 5, 0, 0, 0,
+            99, 107, 32, 83, 97, 98, 114, 101, 32, 38, 32, 78, 101, 119, 32,
-            16, 0, 0, 0, 0, 228, 149, 1, 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            77, 97, 99, 104, 105, 110, 101, 32, 45, 32, 70, 111, 114, 32, 84,
+            104, 101, 32, 87, 101, 101, 107, 101, 110, 100, 32, 40, 50, 48, 50,
+            52, 41, 46, 102, 108, 97, 99, 169, 15, 42, 1, 0, 0, 0, 0, 0, 0, 0,
+            0, 3, 0, 0, 0, 1, 0, 0, 0, 169, 0, 0, 0, 4, 0, 0, 0, 68, 172, 0, 0,
+            5, 0, 0, 0, 16, 0, 0, 0, 0, 228, 149, 1, 0, 46, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0,
         ]
         .to_vec();
         let result = deflate(&data);
@@ -427,4 +454,3 @@ mod tests {
         assert_eq!(decompressed, expect);
     }
 }
-