netherite 0.1.3

A tokio implementation of the Minecraft Protocol with derive macros
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

use std::io::Cursor;

use futures::{Stream, StreamExt};
use tokio_util::codec::FramedRead;

use super::MinecraftCodec;
use crate::codec::{CodecError, RawPacket};

macro_rules! block {
    ($expr:expr) => {
        futures::executor::block_on($expr)
    };
}

fn setup_reader<T>(bytes: T) -> impl Stream<Item = Result<RawPacket, CodecError>>
where
    T: AsRef<[u8]> + Unpin,
{
    FramedRead::new(Cursor::new(bytes), MinecraftCodec::default())
}

// TODO
// fn setup_writer<T>(bytes: impl AsyncWrite) -> impl Sink<RawPacket> {
//     FramedWrite::new(bytes, MinecraftCodec::default())
// }

#[test]
fn invalid_size() {
    let mut reader = setup_reader([0]);
    let res = block!(reader.next()).unwrap();

    assert!(matches!(res, Err(CodecError::Size)))
}

#[test]
fn invalid_packetid() {
    let mut reader = setup_reader([0x02, 0xFF, 0xFF]);
    let res = block!(reader.next()).unwrap();

    assert!(matches!(res, Err(CodecError::Varint(_))))
}

#[test]
fn negative_size() {
    let mut reader = setup_reader([0xff, 0xff, 0xff, 0xff, 0x0f]);
    let res = block!(reader.next()).unwrap();

    assert!(matches!(res, Err(CodecError::Size)))
}

#[test]
fn longer_packetid() {
    let mut reader = setup_reader([0x01, 0xff, 0x01]);
    let res = block!(reader.next()).unwrap();

    assert!(matches!(res, Err(CodecError::Size)))
}

#[test]
fn zero_data() {
    let mut reader = setup_reader([0x02, 0xff, 0x01]);
    let res = block!(reader.next()).unwrap();

    let packet = res.unwrap();

    assert_eq!(packet.data.len(), 0);
}