mcproto-types 0.5.0

Minecraft protocol types.
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

//! Integration tests for the `TypeStructCodec` derive.

use mcproto_codec::error::{CodecErrorKind, CodecKind};
use mcproto_types::{Int, TypeCodec, TypeStructCodec, UnsignedByte};

#[derive(Debug, PartialEq, TypeStructCodec)]
#[type_struct_codec(kind = TypeStruct)]
struct Named {
    first: UnsignedByte,
    second: Int,
}

#[derive(Debug, PartialEq, TypeStructCodec)]
#[type_struct_codec(kind = TypeStruct)]
struct Generic<T>(UnsignedByte, T);

#[derive(Debug, PartialEq, TypeStructCodec)]
#[type_struct_codec(kind = TypeStruct)]
struct Unit;

#[test]
fn named_fields_are_encoded_in_declaration_order() {
    let value = Named {
        first: UnsignedByte(0xaa),
        second: Int(0x0102_0304),
    };
    let mut encoded = Vec::new();
    value.encode(&mut encoded).unwrap();
    assert_eq!(encoded, [0xaa, 0x01, 0x02, 0x03, 0x04]);

    let mut input = encoded.as_slice();
    assert_eq!(Named::decode(&mut input).unwrap(), value);
    assert!(input.is_empty());
}

#[test]
fn tuple_generics_and_unit_structs_are_supported() {
    let value = Generic(UnsignedByte(7), Int(9));
    let mut encoded = Vec::new();
    value.encode(&mut encoded).unwrap();
    let mut input = encoded.as_slice();
    assert_eq!(Generic::<Int>::decode(&mut input).unwrap(), value);

    let mut encoded = Vec::new();
    Unit.encode(&mut encoded).unwrap();
    assert!(encoded.is_empty());
    assert_eq!(Unit::decode(&mut encoded.as_slice()).unwrap(), Unit);
}

#[test]
fn field_errors_keep_the_struct_context() {
    let mut input = [0xaa, 0x01].as_slice();
    let error = Named::decode(&mut input).unwrap_err();
    assert_eq!(error.kind(), CodecErrorKind::UnexpectedEof);
    assert_eq!(error.codec(), CodecKind::Int);
    assert_eq!(error.contexts(), &[CodecKind::TypeStruct]);
    assert_eq!(error.bytes_processed(), 1);
}