removed i24

Author: ismaileke

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "binary-utils"
 authors = ["ismaileke"]
-description = "A binary system to be used for RakNet protocol"
+description = "A binary system to be used for Bedrock & RakNet protocol"
 license = "MIT"
 version = "0.1.0"
 edition = "2021"

src/lib.rs

@@ -173,34 +173,6 @@ pub mod binary {
 
         // ===== 24-bit (triad) integers =====
 
-        /// Reads a 24-bit signed integer (big-endian).
-        #[inline]
-        pub fn get_i24_be(&mut self) -> i32 {
-            let bytes = self.get(3);
-            i32::from_be_bytes([0, bytes[0], bytes[1], bytes[2]])
-        }
-
-        /// Writes a 24-bit signed integer (big-endian).
-        #[inline]
-        pub fn put_i24_be(&mut self, value: i32) {
-            let bytes = value.to_be_bytes();
-            self.buffer.extend_from_slice(&bytes[1..4]);
-        }
-
-        /// Reads a 24-bit signed integer (little-endian).
-        #[inline]
-        pub fn get_i24_le(&mut self) -> i32 {
-            let bytes = self.get(3);
-            i32::from_le_bytes([bytes[0], bytes[1], bytes[2], 0])
-        }
-
-        /// Writes a 24-bit signed integer (little-endian).
-        #[inline]
-        pub fn put_i24_le(&mut self, value: i32) {
-            let bytes = value.to_le_bytes();
-            self.buffer.extend_from_slice(&bytes[0..3]);
-        }
-
         /// Reads a 24-bit unsigned integer (big-endian).
         #[inline]
         pub fn get_u24_be(&mut self) -> u32 {

tests/lib.rs

@@ -5,14 +5,85 @@ mod tests {
 
     use binary_utils::binary::Stream;
 
+    // ===== 24-bit Integer Tests =====
+
+    #[test]
+    fn test_u24_be() {
+        let mut stream = Stream::with_capacity(10);
+        stream.put_u24_be(0xFFFFFF);
+        stream.rewind();
+        assert_eq!(stream.get_u24_be(), 0xFFFFFF);
+    }
+
+    #[test]
+    fn test_u24_le() {
+        let mut stream = Stream::with_capacity(10);
+        stream.put_u24_le(0xFFFFFF);
+        stream.rewind();
+        assert_eq!(stream.get_u24_le(), 0xFFFFFF);
+    }
+
+    // ===== VarInt Tests =====
+
+    #[test]
+    fn test_var_u32_small() {
+        let mut stream = Stream::with_capacity(10);
+        stream.put_var_u32(0);
+        stream.rewind();
+        assert_eq!(stream.get_var_u32(), 0);
+    }
+
+    #[test]
+    fn test_var_u32_large() {
+        let mut stream = Stream::with_capacity(10);
+        stream.put_var_u32(0xFFFFFFFF);
+        stream.rewind();
+        assert_eq!(stream.get_var_u32(), 0xFFFFFFFF);
+    }
+
+    #[test]
+    fn test_var_i32_positive() {
+        let mut stream = Stream::with_capacity(10);
+        stream.put_var_i32(100);
+        stream.rewind();
+        assert_eq!(stream.get_var_i32(), 100);
+    }
+
     #[test]
-    fn test() {
-        println!("{:?}", "167".to_string().into_bytes());
+    fn test_var_i32_negative() {
+        let mut stream = Stream::with_capacity(10);
+        stream.put_var_i32(-100);
+        stream.rewind();
+        let result = stream.get_var_i32();
+        println!("var_i32(-100) = {}", result);
+        assert_eq!(result, -100);
+    }
 
-        let mut stream = Stream::new(vec![19, 54, 55], 0);
+    // ===== VarLong Tests =====
 
-        let result = stream.get_i24_le();
-        println!("result: {}", result);
+    #[test]
+    fn test_var_u64_large() {
+        let mut stream = Stream::with_capacity(20);
+        stream.put_var_u64(0xFFFFFFFFFFFFFFFF);
+        stream.rewind();
+        assert_eq!(stream.get_var_u64(), 0xFFFFFFFFFFFFFFFF);
+    }
+
+    #[test]
+    fn test_var_i64_negative() {
+        let mut stream = Stream::with_capacity(20);
+        stream.put_var_i64(-1);
+        stream.rewind();
+        let result = stream.get_var_i64();
+        println!("var_i64(-1) = {}", result);
+        assert_eq!(result, -1);
+    }
 
+    #[test]
+    fn test_var_i64_positive() {
+        let mut stream = Stream::with_capacity(20);
+        stream.put_var_i64(1000);
+        stream.rewind();
+        assert_eq!(stream.get_var_i64(), 1000);
     }
 }