MeexReay/rust_mc_proto_tokio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

fix tests
Some checks failed
Rust / Build (push) Waiting to run
Details
Rust / Test Suite (push) Waiting to run
Details
Rust / Check (push) Has been cancelled
Details

Browse Source
This commit is contained in:
MeexReay 2025-06-06 15:32:27 +03:00
parent ba2f89b4c4
commit d4df4ff254
2 changed files with 232 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/data/reader.rs
View File

@ -75,6 +75,15 @@ pub trait DataReader {
}} }}
} }
/// Read VarInt as u8
async fn read_u8_varint(&mut self) -> Result<u8, ProtocolError> {
TryInto::<u8>::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarInt as u16
async fn read_u16_varint(&mut self) -> Result<u16, ProtocolError> {
TryInto::<u16>::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarInt as u32 /// Read VarInt as u32
/// ///
/// Returns error if the value is greater than i32::MAX /// Returns error if the value is greater than i32::MAX

379
src/tests.rs
View File

@ -5,186 +5,253 @@ use std::io::Cursor;
use crate::*; use crate::*;
#[tokio::test] #[tokio::test]
async fn test_varint() -> Result<(), ProtocolError> { async fn test_varints() -> Result<(), ProtocolError> {
let mut src = Packet::empty(0x00); /*
Sample VarInts:
src.write_u8_varint(0).await?; // 0x00 | Value | Hex bytes |
src.write_u8_varint(1).await?; // 0x01 | ------------ | ---------------------------- |
src.write_u8_varint(2).await?; // 0x02 | 0 | 0x00 |
src.write_u8_varint(127).await?; // 0x7f | 1 | 0x01 |
src.write_u8_varint(128).await?; // 0x80 0x01 | 2 | 0x02 |
src.write_u16_varint(255).await?; // 0xff 0x01 | 127 | 0x7f |
src.write_u16_varint(25565).await?; // 0xdd 0xc7 0x01 | 128 | 0x80, 0x01 |
src.write_u32_varint(2097151).await?; // 0xff 0xff 0x7f | 255 | 0xff, 0x01 |
src.write_u32_varint(2147483647).await?; // 0xff 0xff 0xff 0xff 0x07 | 25565 | 0xdd, 0xc7, 0x01 |
src.write_i8_varint(-1).await?; // 0xff 0xff 0xff 0xff 0x0f | 2097151 | 0xff, 0xff, 0x7f |
src.write_i32_varint(-2147483648).await?; // 0x80 0x80 0x80 0x80 0x08 | 2147483647 | 0xff, 0xff, 0xff, 0xff, 0x07 |
| -1 | 0xff, 0xff, 0xff, 0xff, 0x0f |
| -2147483648 | 0x80, 0x80, 0x80, 0x80, 0x08 |
let mut packet = Packet::from_bytes(0x00, src.get_bytes()); */
let mut packet = Packet::empty(0x00);
packet.write_u8_varint(0).await?;
packet.write_u8_varint(1).await?;
packet.write_u8_varint(2).await?;
packet.write_u8_varint(127).await?;
packet.write_u8_varint(128).await?;
packet.write_u8_varint(255).await?;
packet.write_u16_varint(25565).await?;
packet.write_u32_varint(2097151).await?;
packet.write_u32_varint(2147483647).await?;
packet.write_i8_varint(-1).await?;
packet.write_i32_varint(-2147483648).await?;
packet.get_mut().set_position(0);
assert_eq!(packet.read_bytes(1).await?, &[0x00]); // 0
assert_eq!(packet.read_bytes(1).await?, &[0x01]); // 1
assert_eq!(packet.read_bytes(1).await?, &[0x02]); // 2
assert_eq!(packet.read_bytes(1).await?, &[0x7f]); // 127
assert_eq!(packet.read_bytes(2).await?, &[0x80, 0x01]); // 128
assert_eq!(packet.read_bytes(2).await?, &[0xff, 0x01]); // 255
assert_eq!(packet.read_bytes(3).await?, &[0xdd, 0xc7, 0x01]); // 25565
assert_eq!(packet.read_bytes(3).await?, &[0xff, 0xff, 0x7f]); // 2097151
assert_eq!(packet.read_bytes(5).await?, &[0xff, 0xff, 0xff, 0xff, 0x07]); // 2147483647
assert_eq!(packet.read_bytes(5).await?, &[0xff, 0xff, 0xff, 0xff, 0x0f]); // -1
assert_eq!(packet.read_bytes(5).await?, &[0x80, 0x80, 0x80, 0x80, 0x08]); // -2147483648
packet.get_mut().set_position(0);
assert_eq!(packet.read_u8_varint().await?, 0); assert_eq!(packet.read_u8_varint().await?, 0);
assert_eq!(packet.read_u8_varint().await?, 1); assert_eq!(packet.read_u8_varint().await?, 1);
assert_eq!(packet.read_u8_varint().await?, 2); assert_eq!(packet.read_u8_varint().await?, 2);
assert_eq!(packet.read_u8_varint().await?, 127); assert_eq!(packet.read_u8_varint().await?, 127);
assert_eq!(packet.read_u8_varint().await?, 128); assert_eq!(packet.read_u8_varint().await?, 128);
assert_eq!(packet.read_u16_varint().await?, 255); assert_eq!(packet.read_u8_varint().await?, 255);
assert_eq!(packet.read_u16_varint().await?, 25565); assert_eq!(packet.read_u16_varint().await?, 25565);
assert_eq!(packet.read_u32_varint().await?, 2097151); assert_eq!(packet.read_u32_varint().await?, 2097151);
assert_eq!(packet.read_u32_varint().await?, 2147483647); assert_eq!(packet.read_u32_varint().await?, 2147483647);
assert_eq!(packet.read_i8_varint().await?, -1); assert_eq!(packet.read_i32_varint().await?, -1);
assert_eq!(packet.read_i32_varint().await?, -2147483648); assert_eq!(packet.read_i32_varint().await?, -2147483648);
let mut packet = Packet::from_bytes(0x00, src.get_bytes());
assert_eq!(packet.read_bytes(1).await?, vec![0x00]); // 0
assert_eq!(packet.read_bytes(1).await?, vec![0x01]); // 1
assert_eq!(packet.read_bytes(1).await?, vec![0x02]); // 2
assert_eq!(packet.read_bytes(1).await?, vec![0x7f]); // 127
assert_eq!(packet.read_bytes(2).await?, vec![0x80, 0x01]); // 128
assert_eq!(packet.read_bytes(2).await?, vec![0xff, 0x01]); // 255
assert_eq!(packet.read_bytes(3).await?, vec![0xdd, 0xc7, 0x01]); // 25565
assert_eq!(packet.read_bytes(3).await?, vec![0xff, 0xff, 0x7f]); // 2097151
assert_eq!(packet.read_bytes(5).await?, vec![0xff, 0xff, 0xff, 0xff, 0x07]); // 2147483647
assert_eq!(packet.read_bytes(5).await?, vec![0xff, 0xff, 0xff, 0xff, 0x0f]); // -1
assert_eq!(packet.read_bytes(5).await?, vec![0x80, 0x80, 0x80, 0x80, 0x08]); // -2147483648
Ok(()) Ok(())
} }
#[tokio::test] #[tokio::test]
async fn test_data_transfer() -> Result<(), ProtocolError> { async fn test_varlongs() -> Result<(), ProtocolError> {
/*
async fn server_thread() -> Result<(), ProtocolError> {
let listener =
TcpListener::bind("localhost:44447").await.or(Err(ProtocolError::StreamConnectError))?;
while let Ok((stream, _)) = listener.accept().await {
let mut stream = MCConnTcp::new(stream);
stream.set_compression(Some(5));
let mut packet = stream.read_packet().await?;
let mut pack = Packet::empty(packet.id());
pack.write_boolean(packet.read_boolean().await?).await?;
pack.write_byte(packet.read_byte().await?).await?;
pack.write_bytes(&packet.read_bytes(10).await?.clone()).await?;
pack.write_double(packet.read_double().await?).await?;
pack.write_float(packet.read_float().await?).await?;
pack.write_i128_varint(packet.read_i128_varint().await?).await?;
pack.write_u128_varint(packet.read_u128_varint().await?).await?;
pack.write_int(packet.read_int().await?).await?;
pack.write_long(packet.read_long().await?).await?;
pack.write_short(packet.read_short().await?).await?;
pack.write_uuid(&packet.read_uuid().await?).await?;
pack.write_string(&packet.read_string().await?.clone()).await?;
stream.write_packet(&pack).await?;
stream.set_compression(None);
let mut packet = stream.read_packet().await?;
let mut pack = Packet::empty(packet.id());
pack.write_boolean(packet.read_boolean().await?).await?;
pack.write_byte(packet.read_byte().await?).await?;
pack.write_bytes(&packet.read_bytes(10).await?.clone()).await?;
pack.write_double(packet.read_double().await?).await?;
pack.write_float(packet.read_float().await?).await?;
pack.write_i128_varint(packet.read_i128_varint().await?).await?;
pack.write_u128_varint(packet.read_u128_varint().await?).await?;
pack.write_int(packet.read_int().await?).await?;
pack.write_long(packet.read_long().await?).await?;
pack.write_short(packet.read_short().await?).await?;
pack.write_uuid(&packet.read_uuid().await?).await?;
pack.write_string(&packet.read_string().await?.clone()).await?;
stream.write_packet(&pack).await?;
}
Ok(())
}
tokio::spawn(async { let _ = server_thread().await; });
let mut conn = loop {
match MCConnTcp::connect("localhost:44447").await {
Ok(i) => break i,
Err(_) => {}
};
};
conn.set_compression(Some(5));
let mut pack = Packet::empty(0xfe);
pack.write_boolean(true).await?;
pack.write_byte(0x12).await?;
pack.write_bytes(&vec![0x01, 0x56, 0x47, 0x48, 0xf5, 0xc2, 0x45, 0x98, 0xde, 0x99]).await?;
pack.write_double(123456789.123456789f64).await?;
pack.write_float(789456.44422f32).await?;
pack.write_i128_varint(468927513325566).await?;
pack.write_u128_varint(99859652365236523).await?;
pack.write_int(77861346i32).await?;
pack.write_long(789465123545678946i64).await?;
pack.write_short(1233i16).await?;
pack.write_uuid(&Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000").map_err(|_| ProtocolError::CloneError)?).await?;
pack.write_string("&packet.read_string()?").await?;
conn.write_packet(&pack).await?;
let mut packet = conn.read_packet().await?;
assert_eq!(packet.read_boolean().await?, true);
assert_eq!(packet.read_byte().await?, 0x12);
assert_eq!(packet.read_bytes(10).await?, vec![0x01, 0x56, 0x47, 0x48, 0xf5, 0xc2, 0x45, 0x98, 0xde, 0x99]);
assert_eq!(packet.read_double().await?, 123456789.123456789f64);
assert_eq!(packet.read_float().await?, 789456.44422f32);
assert_eq!(packet.read_i128_varint().await?, 468927513325566);
assert_eq!(packet.read_u128_varint().await?, 99859652365236523);
assert_eq!(packet.read_int().await?, 77861346i32);
assert_eq!(packet.read_long().await?, 789465123545678946i64);
assert_eq!(packet.read_short().await?, 1233i16);
assert_eq!(packet.read_uuid().await?, Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000").map_err(|_| ProtocolError::CloneError)?);
assert_eq!(packet.read_string().await?, "&packet.read_string()?");
conn.set_compression(None);
let mut pack = Packet::empty(0xfe);
pack.write_boolean(true).await?; Sample VarLongs:
pack.write_byte(0x12).await?;
pack.write_bytes(&vec![0x01, 0x56, 0x47, 0x48, 0xf5, 0xc2, 0x45, 0x98, 0xde, 0x99]).await?;
pack.write_double(123456789.123456789f64).await?;
pack.write_float(789456.44422f32).await?;
pack.write_i128_varint(468927513325566).await?;
pack.write_u128_varint(99859652365236523).await?;
pack.write_int(77861346i32).await?;
pack.write_long(789465123545678946i64).await?;
pack.write_short(1233i16).await?;
pack.write_uuid(&Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000").map_err(|_| ProtocolError::CloneError)?).await?;
pack.write_string("&packet.read_string()?").await?;
conn.write_packet(&pack).await?; | Value | Hex bytes |
| --------------------- | ---------------------------------------------------------- |
| 0 | 0x00 |
| 1 | 0x01 |
| 2 | 0x02 |
| 127 | 0x7f |
| 128 | 0x80, 0x01 |
| 255 | 0xff, 0x01 |
| 2147483647 | 0xff, 0xff, 0xff, 0xff, 0x07 |
| 9223372036854775807 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, |
| -1 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01 |
| -2147483648 | 0x80, 0x80, 0x80, 0x80, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01 |
| -9223372036854775808 | 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01 |
*/
let mut packet = conn.read_packet().await?; let mut packet = Packet::empty(0x00);
assert_eq!(packet.read_boolean().await?, true); packet.write_u8_varlong(0).await?;
assert_eq!(packet.read_byte().await?, 0x12); packet.write_u8_varlong(1).await?;
assert_eq!(packet.read_bytes(10).await?, vec![0x01, 0x56, 0x47, 0x48, 0xf5, 0xc2, 0x45, 0x98, 0xde, 0x99]); packet.write_u8_varlong(2).await?;
assert_eq!(packet.read_double().await?, 123456789.123456789f64); packet.write_u8_varlong(127).await?;
assert_eq!(packet.read_float().await?, 789456.44422f32); packet.write_u8_varlong(128).await?;
assert_eq!(packet.read_i128_varint().await?, 468927513325566); packet.write_u8_varlong(255).await?;
assert_eq!(packet.read_u128_varint().await?, 99859652365236523); packet.write_u32_varlong(2147483647).await?;
assert_eq!(packet.read_int().await?, 77861346i32); packet.write_u64_varlong(9223372036854775807).await?;
assert_eq!(packet.read_long().await?, 789465123545678946i64); packet.write_i8_varlong(-1).await?;
assert_eq!(packet.read_short().await?, 1233i16); packet.write_i32_varlong(-2147483648).await?;
assert_eq!(packet.read_uuid().await?, Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000").map_err(|_| ProtocolError::CloneError)?); packet.write_i64_varlong(-9223372036854775808).await?;
assert_eq!(packet.read_string().await?, "&packet.read_string()?");
packet.get_mut().set_position(0);
assert_eq!(packet.read_bytes(1).await?, &[0x00]); // 0
assert_eq!(packet.read_bytes(1).await?, &[0x01]); // 1
assert_eq!(packet.read_bytes(1).await?, &[0x02]); // 2
assert_eq!(packet.read_bytes(1).await?, &[0x7f]); // 127
assert_eq!(packet.read_bytes(2).await?, &[0x80, 0x01]); // 128
assert_eq!(packet.read_bytes(2).await?, &[0xff, 0x01]); // 255
assert_eq!(packet.read_bytes(5).await?, &[0xff, 0xff, 0xff, 0xff, 0x07]); // 2147483647
assert_eq!(packet.read_bytes(9).await?, &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]); // 9223372036854775807
assert_eq!(packet.read_bytes(10).await?, &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01]); // -1
assert_eq!(packet.read_bytes(10).await?, &[0x80, 0x80, 0x80, 0x80, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01]); // -2147483648
assert_eq!(packet.read_bytes(10).await?, &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01]); // -9223372036854775808
packet.get_mut().set_position(0);
assert_eq!(packet.read_u8_varlong().await?, 0);
assert_eq!(packet.read_u8_varlong().await?, 1);
assert_eq!(packet.read_u8_varlong().await?, 2);
assert_eq!(packet.read_u8_varlong().await?, 127);
assert_eq!(packet.read_u8_varlong().await?, 128);
assert_eq!(packet.read_u8_varlong().await?, 255);
assert_eq!(packet.read_u32_varlong().await?, 2147483647);
assert_eq!(packet.read_u64_varlong().await?, 9223372036854775807);
assert_eq!(packet.read_i8_varlong().await?, -1);
assert_eq!(packet.read_i32_varlong().await?, -2147483648);
assert_eq!(packet.read_i64_varlong().await?, -9223372036854775808);
Ok(()) Ok(())
} }
// #[tokio::test]
// async fn test_data_transfer() -> Result<(), ProtocolError> {
// fn server_thread(listener: TcpListener) -> Result<(), ProtocolError> {
// for stream in listener.incoming() {
// let mut stream = MCConnTcp::new(stream.or(Err(ProtocolError::StreamConnectError))?);
// stream.set_compression(Some(5));
// let mut packet = stream.read_packet()?;
// stream.write_packet(&Packet::build(packet.id(), |pack| {
// pack.write_boolean(packet.read_boolean()?)?;
// pack.write_byte(packet.read_byte()?)?;
// pack.write_bytes(&packet.read_bytes(10)?)?;
// pack.write_double(packet.read_double()?)?;
// pack.write_float(packet.read_float()?)?;
// pack.write_varint(packet.read_varint()?)?;
// pack.write_varlong(packet.read_varlong()?)?;
// pack.write_int(packet.read_int()?)?;
// pack.write_long(packet.read_long()?)?;
// pack.write_short(packet.read_short()?)?;
// pack.write_uuid(&packet.read_uuid()?)?;
// pack.write_string(&packet.read_string()?)?;
// Ok(())
// })?)?;
// stream.set_compression(None);
// let mut packet = stream.read_packet()?;
// stream.write_packet(&Packet::build(packet.id(), |pack| {
// pack.write_boolean(packet.read_boolean()?)?;
// pack.write_byte(packet.read_byte()?)?;
// pack.write_bytes(&packet.read_bytes(10)?)?;
// pack.write_double(packet.read_double()?)?;
// pack.write_float(packet.read_float()?)?;
// pack.write_varint(packet.read_varint()?)?;
// pack.write_varlong(packet.read_varlong()?)?;
// pack.write_int(packet.read_int()?)?;
// pack.write_long(packet.read_long()?)?;
// pack.write_short(packet.read_short()?)?;
// pack.write_uuid(&packet.read_uuid()?)?;
// pack.write_string(&packet.read_string()?)?;
// Ok(())
// })?)?;
// }
// Ok(())
// }
// fn test_conn(conn: &mut MinecraftConnection<TcpStream>) -> Result<(), ProtocolError> {
// conn.write_packet(&Packet::build(0xfe, |pack| {
// pack.write_boolean(true)?;
// pack.write_byte(0x12)?;
// pack.write_bytes(&vec![0x01, 0x56, 0x47, 0x48, 0xf5, 0xc2, 0x45, 0x98, 0xde, 0x99])?;
// pack.write_double(123456789.123456789f64)?;
// pack.write_float(789456.44422f32)?;
// pack.write_varint(468927512)?;
// pack.write_varlong(99859652365236523)?;
// pack.write_int(77861346i32)?;
// pack.write_long(789465123545678946i64)?;
// pack.write_short(1233i16)?;
// pack.write_uuid(&Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000").map_err(|_| ProtocolError::CloneError)?)?;
// pack.write_string("&packet.read_string()?")?;
// Ok(())
// })?)?;
// let mut packet = conn.read_packet()?;
// assert_eq!(packet.read_boolean()?, true);
// assert_eq!(packet.read_byte()?, 0x12);
// assert_eq!(packet.read_bytes(10)?, vec![0x01, 0x56, 0x47, 0x48, 0xf5, 0xc2, 0x45, 0x98, 0xde, 0x99]);
// assert_eq!(packet.read_double()?, 123456789.123456789f64);
// assert_eq!(packet.read_float()?, 789456.44422f32);
// assert_eq!(packet.read_varint()?, 468927512);
// assert_eq!(packet.read_varlong()?, 99859652365236523);
// assert_eq!(packet.read_int()?, 77861346i32);
// assert_eq!(packet.read_long()?, 789465123545678946i64);
// assert_eq!(packet.read_short()?, 1233i16);
// assert_eq!(packet.read_uuid()?, Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000").map_err(|_| ProtocolError::CloneError)?);
// assert_eq!(packet.read_string()?, "&packet.read_string()?");
// Ok(())
// }
// let listener =
// TcpListener::bind("127.0.0.1:0").or(Err(ProtocolError::StreamConnectError))?;
// let addr = listener.local_addr().expect("local addr error");
// thread::spawn(move || {
// server_thread(listener).expect("server error")
// });
// let mut conn = loop {
// if let Ok(conn) = MCConnTcp::connect(addr) {
// break conn;
// } else {
// thread::sleep(Duration::from_millis(10));
// }
// };
// conn.set_compression(Some(5));
// test_conn(&mut conn)?;
// conn.set_compression(None);
// test_conn(&mut conn)?;
// Ok(())
// }
#[tokio::test] #[tokio::test]
async fn test_compression() -> Result<(), ProtocolError> { async fn test_compression() -> Result<(), ProtocolError> {
let mut conn = MCConn::new(Cursor::new(Vec::new())); let mut conn = MCConn::new(Cursor::new(Vec::new()));