cubic-protocol 0.1.11

Minecraft protocol on rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use crate::packet::*;
use crate::types::*;
use crate::packet_bytes::*;
use crate::packet_default::*;

mod primitives {
    use super::*;

    #[actix_rt::test]
    async fn numbers_test() {
        {
            let mut output = OutputPacketBytesVec::new();
            1_u8.write(&mut output).await.unwrap();
            2_u16.write(&mut output).await.unwrap();
            53232323_u32.write(&mut output).await.unwrap();
            43295438_i32.write(&mut output).await.unwrap();
            assert_eq!(output.data, vec![
                0x01,
                0x00, 0x02,
                0x03, 0x2c, 0x42, 0xc3,
                0x02, 0x94, 0xa2, 0xce,
            ])
        }
        {
            let mut input = InputPacketBytesPrepared::from(
                vec![0x03, 0xc3, 0x33, 0x21, 0x49, 0x12, 0x32]
            );
            assert_eq!(u8::read(&mut input).await.unwrap(), 0x03);
            assert_eq!(u32::read(&mut input).await.unwrap(), 0xc3332149);
            assert_eq!(u16::read(&mut input).await.unwrap(), 0x1232);
        }
    }

    #[actix_rt::test]
    async fn var_numbers_test() {
        {
            let mut output = OutputPacketBytesVec::new();
            VarInt(2097151).write(&mut output).await.unwrap();
            VarInt(2147483647).write(&mut output).await.unwrap();
            VarInt(-2147483648).write(&mut output).await.unwrap();
            VarInt(-1).write(&mut output).await.unwrap();
            VarLong(9223372036854775807).write(&mut output).await.unwrap();
            VarLong(-9223372036854775808).write(&mut output).await.unwrap();
            assert_eq!(
                output.data,
                vec![
                    0xff, 0xff, 0x7f,
                    0xff, 0xff, 0xff, 0xff, 0x07,
                    0x80, 0x80, 0x80, 0x80, 0x08,
                    0xff, 0xff, 0xff, 0xff, 0x0f,
                    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
                    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01,
                ]
            );
            let mut input = InputPacketBytesPrepared::from(output);
            assert_eq!(VarInt::read(&mut input).await.unwrap().0, 2097151);
            assert_eq!(VarInt::read(&mut input).await.unwrap().0, 2147483647);
            assert_eq!(VarInt::read(&mut input).await.unwrap().0, -2147483648);
            assert_eq!(VarInt::read(&mut input).await.unwrap().0, -1);
            assert_eq!(VarLong::read(&mut input).await.unwrap().0, 9223372036854775807);
            assert_eq!(VarLong::read(&mut input).await.unwrap().0, -9223372036854775808);
        }
    }

    #[actix_rt::test]
    async fn string_test() {
        {
            let mut output = OutputPacketBytesVec::new();
            "jenya705".write(&mut output).await.unwrap();
            "рашн ленг".write(&mut output).await.unwrap();
            let mut input = InputPacketBytesPrepared::from(output);
            assert_eq!(String::read(&mut input).await.unwrap(), "jenya705");
            assert_eq!(String::read(&mut input).await.unwrap(), "рашн ленг");
        }
    }

    #[actix_rt::test]
    async fn block_position_test() {
        {
            let position = BlockPosition::new(32, -32, -32195);
            let mut output = OutputPacketBytesVec::new();
            position.write(&mut output).await.unwrap();
            let mut input = InputPacketBytesPrepared::from(output);
            assert_eq!(BlockPosition::read(&mut input).await.unwrap(), position);
        }
    }
}

mod packets {
    use super::*;

    #[actix_rt::test]
    async fn handshake_test() {
        {
            let mut output = OutputPacketBytesVec::new();
            <Handshaking as PacketWritable>::write(
                Handshaking {
                    next_state: 1,
                    server_address: "localhost".into(),
                    server_port: 25565,
                    protocol_version: 759,
                }, &mut output,
            ).await.unwrap();
            assert_eq!(output.data, vec![0, 247, 5, 9, 108, 111, 99, 97, 108, 104, 111, 115, 116, 99, 221, 1])
        }
        {
            let mut input = InputPacketBytesPrepared::from(
                vec![247, 5, 9, 108, 111, 99, 97, 108, 104, 111, 115, 116, 99, 221, 1]
            );
            assert_eq!(
                <Handshaking as PacketReadable>::read(&mut input).await.unwrap(),
                Handshaking {
                    next_state: 1,
                    server_address: "localhost".into(),
                    server_port: 25565,
                    protocol_version: 759,
                }
            );
        }
        {
            let mut input = InputPacketBytesPrepared::from(
                vec![0, 247, 5, 9, 108, 111, 99, 97, 108, 104, 111, 115, 116, 99, 221, 1]
            );
            let packet = ClientHandshakePacket::read(&mut input).await.unwrap();
            assert_eq!(
                packet,
                ClientHandshakePacket::Handshaking(Handshaking {
                    next_state: 1,
                    server_address: "localhost".into(),
                    server_port: 25565,
                    protocol_version: 759,
                })
            )
        }
    }
}