Merge branch 'main' into chunk-decoding

1 files changed, 55 insertions, 59 deletions

diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index d50817fb..a61ad3c3 100755
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -4,7 +4,7 @@ mod read;
 mod write;
 
 use packet_macros::{McBufReadable, McBufWritable};
-pub use read::{McBufReadable, McBufVarintReadable, Readable};
+pub use read::{read_varint_async, McBufReadable, McBufVarintReadable, Readable};
 use std::ops::{Deref, Index};
 pub use write::{McBufVarintWritable, McBufWritable, Writable};
 
@@ -56,7 +56,6 @@ mod tests {
     use super::*;
     use azalea_core::resource_location::ResourceLocation;
     use std::{collections::HashMap, io::Cursor};
-    use tokio::io::BufReader;
 
     #[test]
     fn test_write_varint() {
@@ -105,91 +104,91 @@ mod tests {
         assert_eq!(buf, vec![128, 128, 128, 128, 8]);
     }
 
-    #[tokio::test]
-    async fn test_read_varint() {
-        let mut buf = BufReader::new(Cursor::new(vec![0]));
-        assert_eq!(buf.read_varint().await.unwrap(), 0);
+    #[test]
+    fn test_read_varint() {
+        let mut buf = Cursor::new(vec![0]);
+        assert_eq!(buf.read_varint().unwrap(), 0);
         assert_eq!(buf.get_varint_size(0), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 1);
+        let mut buf = Cursor::new(vec![1]);
+        assert_eq!(buf.read_varint().unwrap(), 1);
         assert_eq!(buf.get_varint_size(1), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![2]));
-        assert_eq!(buf.read_varint().await.unwrap(), 2);
+        let mut buf = Cursor::new(vec![2]);
+        assert_eq!(buf.read_varint().unwrap(), 2);
         assert_eq!(buf.get_varint_size(2), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![127]));
-        assert_eq!(buf.read_varint().await.unwrap(), 127);
+        let mut buf = Cursor::new(vec![127]);
+        assert_eq!(buf.read_varint().unwrap(), 127);
         assert_eq!(buf.get_varint_size(127), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![128, 1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 128);
+        let mut buf = Cursor::new(vec![128, 1]);
+        assert_eq!(buf.read_varint().unwrap(), 128);
         assert_eq!(buf.get_varint_size(128), 2);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 255);
+        let mut buf = Cursor::new(vec![255, 1]);
+        assert_eq!(buf.read_varint().unwrap(), 255);
         assert_eq!(buf.get_varint_size(255), 2);
 
-        let mut buf = BufReader::new(Cursor::new(vec![221, 199, 1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 25565);
+        let mut buf = Cursor::new(vec![221, 199, 1]);
+        assert_eq!(buf.read_varint().unwrap(), 25565);
         assert_eq!(buf.get_varint_size(25565), 3);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 255, 127]));
-        assert_eq!(buf.read_varint().await.unwrap(), 2097151);
+        let mut buf = Cursor::new(vec![255, 255, 127]);
+        assert_eq!(buf.read_varint().unwrap(), 2097151);
         assert_eq!(buf.get_varint_size(2097151), 3);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 255, 255, 255, 7]));
-        assert_eq!(buf.read_varint().await.unwrap(), 2147483647);
+        let mut buf = Cursor::new(vec![255, 255, 255, 255, 7]);
+        assert_eq!(buf.read_varint().unwrap(), 2147483647);
         assert_eq!(buf.get_varint_size(2147483647), 5);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 255, 255, 255, 15]));
-        assert_eq!(buf.read_varint().await.unwrap(), -1);
+        let mut buf = Cursor::new(vec![255, 255, 255, 255, 15]);
+        assert_eq!(buf.read_varint().unwrap(), -1);
         assert_eq!(buf.get_varint_size(-1), 5);
 
-        let mut buf = BufReader::new(Cursor::new(vec![128, 128, 128, 128, 8]));
-        assert_eq!(buf.read_varint().await.unwrap(), -2147483648);
+        let mut buf = Cursor::new(vec![128, 128, 128, 128, 8]);
+        assert_eq!(buf.read_varint().unwrap(), -2147483648);
         assert_eq!(buf.get_varint_size(-2147483648), 5);
     }
 
-    #[tokio::test]
-    async fn test_read_varint_longer() {
-        let mut buf = BufReader::new(Cursor::new(vec![138, 56, 0, 135, 56, 123]));
-        assert_eq!(buf.read_varint().await.unwrap(), 7178);
+    #[test]
+    fn test_read_varint_longer() {
+        let mut buf = Cursor::new(vec![138, 56, 0, 135, 56, 123]);
+        assert_eq!(buf.read_varint().unwrap(), 7178);
     }
 
-    #[tokio::test]
-    async fn test_list() {
+    #[test]
+    fn test_list() {
         let mut buf = Vec::new();
         buf.write_list(&vec!["a", "bc", "def"], |buf, s| buf.write_utf(s))
             .unwrap();
 
         // there's no read_list because idk how to do it in rust
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
         let mut result = Vec::new();
-        let length = buf.read_varint().await.unwrap();
+        let length = buf.read_varint().unwrap();
         for _ in 0..length {
-            result.push(buf.read_utf().await.unwrap());
+            result.push(buf.read_utf().unwrap());
         }
 
         assert_eq!(result, vec!["a", "bc", "def"]);
     }
 
-    #[tokio::test]
-    async fn test_int_id_list() {
+    #[test]
+    fn test_int_id_list() {
         let mut buf = Vec::new();
         buf.write_list(&vec![1, 2, 3], |buf, i| buf.write_varint(*i))
             .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
-        let result = buf.read_int_id_list().await.unwrap();
+        let result = buf.read_int_id_list().unwrap();
         assert_eq!(result, vec![1, 2, 3]);
     }
 
-    #[tokio::test]
-    async fn test_map() {
+    #[test]
+    fn test_map() {
         let mut buf = Vec::new();
         buf.write_map(
             vec![("a", 1), ("bc", 23), ("def", 456)],
@@ -198,15 +197,12 @@ mod tests {
         )
         .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
         let mut result = Vec::new();
-        let length = buf.read_varint().await.unwrap();
+        let length = buf.read_varint().unwrap();
         for _ in 0..length {
-            result.push((
-                buf.read_utf().await.unwrap(),
-                buf.read_varint().await.unwrap(),
-            ));
+            result.push((buf.read_utf().unwrap(), buf.read_varint().unwrap()));
         }
 
         assert_eq!(
@@ -219,8 +215,8 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn test_nbt() {
+    #[test]
+    fn test_nbt() {
         let mut buf = Vec::new();
         buf.write_nbt(&azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
             "hello world".to_string(),
@@ -231,9 +227,9 @@ mod tests {
         )])))
         .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
-        let result = buf.read_nbt().await.unwrap();
+        let result = buf.read_nbt().unwrap();
         assert_eq!(
             result,
             azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
@@ -246,26 +242,26 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn test_long() {
+    #[test]
+    fn test_long() {
         let mut buf = Vec::new();
         buf.write_long(123456).unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
-        assert_eq!(buf.read_long().await.unwrap(), 123456);
+        assert_eq!(buf.read_long().unwrap(), 123456);
     }
 
-    #[tokio::test]
-    async fn test_resource_location() {
+    #[test]
+    fn test_resource_location() {
         let mut buf = Vec::new();
         buf.write_resource_location(&ResourceLocation::new("minecraft:dirt").unwrap())
             .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
         assert_eq!(
-            buf.read_resource_location().await.unwrap(),
+            buf.read_resource_location().unwrap(),
             ResourceLocation::new("minecraft:dirt").unwrap()
         );
     }