Skip to main content

azalea_protocol/
lib.rs

1#![doc = include_str!("../README.md")]
2// this is necessary for thiserror backtraces
3#![feature(error_generic_member_access)]
4
5pub mod address;
6pub mod common;
7#[cfg(feature = "connecting")]
8pub mod connect;
9pub mod packets;
10pub mod read;
11pub mod resolve;
12pub mod write;
13
14// re-export for internal use in azalea-client
15#[doc(hidden)]
16pub use azalea_protocol_macros;
17// re-export to make it easier for users to have the correct version
18pub use simdnbt;
19
20#[doc(hidden)]
21#[deprecated(note = "renamed to `resolve`.")]
22pub mod resolver {
23    pub use super::resolve::*;
24}
25
26#[doc(hidden)]
27#[deprecated(note = "moved to `address::ServerAddr`.")]
28pub type ServerAddress = address::ServerAddr;
29
30#[cfg(test)]
31mod tests {
32    use std::io::Cursor;
33
34    use uuid::Uuid;
35
36    use crate::{
37        packets::{
38            Packet,
39            game::s_chat::{LastSeenMessagesUpdate, ServerboundChat},
40            login::{ServerboundLoginPacket, s_hello::ServerboundHello},
41        },
42        read::{compression_decoder, read_packet},
43        write::{compression_encoder, serialize_packet, write_packet},
44    };
45
46    #[tokio::test]
47    async fn test_hello_packet() {
48        let packet = ServerboundHello {
49            name: "test".to_owned(),
50            profile_id: Uuid::nil(),
51        };
52        let mut stream = Vec::new();
53        write_packet(&packet.into_variant(), &mut stream, None, &mut None)
54            .await
55            .unwrap();
56
57        assert_eq!(
58            stream,
59            [
60                22, 0, 4, 116, 101, 115, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
61            ]
62        );
63
64        let mut stream = Cursor::new(stream);
65
66        let _ = read_packet::<ServerboundLoginPacket, _>(
67            &mut stream,
68            &mut Cursor::new(Vec::new()),
69            None,
70            &mut None,
71        )
72        .await
73        .unwrap();
74    }
75
76    #[tokio::test]
77    async fn test_double_hello_packet() {
78        let packet = ServerboundHello {
79            name: "test".to_owned(),
80            profile_id: Uuid::nil(),
81        }
82        .into_variant();
83        let mut stream = Vec::new();
84        write_packet(&packet, &mut stream, None, &mut None)
85            .await
86            .unwrap();
87        write_packet(&packet, &mut stream, None, &mut None)
88            .await
89            .unwrap();
90        let mut stream = Cursor::new(stream);
91
92        let mut buffer = Cursor::new(Vec::new());
93
94        let _ = read_packet::<ServerboundLoginPacket, _>(&mut stream, &mut buffer, None, &mut None)
95            .await
96            .unwrap();
97        let _ = read_packet::<ServerboundLoginPacket, _>(&mut stream, &mut buffer, None, &mut None)
98            .await
99            .unwrap();
100    }
101
102    #[tokio::test]
103    async fn test_read_long_compressed_chat() {
104        let compression_threshold = 256;
105
106        let buf = serialize_packet(
107            &ServerboundChat {
108                message: "a".repeat(256),
109                timestamp: 0,
110                salt: 0,
111                signature: None,
112                last_seen_messages: LastSeenMessagesUpdate::default(),
113            }
114            .into_variant(),
115        )
116        .unwrap();
117
118        let buf = compression_encoder(&buf, compression_threshold).unwrap();
119
120        println!("{buf:?}");
121
122        compression_decoder(&mut Cursor::new(&buf), compression_threshold).unwrap();
123    }
124}