resynth 0.4.0

A packet synthesis language
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

use crate::err::Error::{NameError, TypeError};
use crate::libapi::{Class, ClassDef};
use crate::object::ObjRef;
use crate::sym::Symbol;
use crate::val::{Val, ValDef};

#[derive(Debug, PartialEq, Eq)]
pub(self) struct Tcp {
    pub cl_seq: u32,
    pub sv_seq: u32,
}

const TCP: ClassDef = class!(
    /// TCP Session
    resynth class Tcp {
        client_message => Symbol::Val(ValDef::U64(1)),
        server_message => Symbol::Val(ValDef::U64(2)),
    }
);

impl Class for Tcp {
    fn def(&self) -> &'static ClassDef {
        &TCP
    }
}

impl Tcp {
    pub(self) fn new(cl_seq: u32, sv_seq: u32) -> Self {
        Self { cl_seq, sv_seq }
    }
}

#[derive(Debug, PartialEq, Eq)]
pub(self) struct Udp {}

const UDP: ClassDef = class!(
    /// UDP Session
    resynth class Udp {
        client_dgram => Symbol::Val(ValDef::U64(1)),
        server_dgram => Symbol::Val(ValDef::U64(2)),
    }
);

impl Class for Udp {
    fn def(&self) -> &'static ClassDef {
        &UDP
    }
}

impl Udp {
    pub(self) fn new() -> Self {
        Self {}
    }
}

///////////////////////////////////////////////////////////////////////////////

#[test]
fn obj_eq() {
    let a = Val::from(Tcp::new(123, 456));
    let b = Val::from(Tcp::new(123, 456));
    assert_eq!(a, b);
}

#[test]
fn obj_neq_nil() {
    let a = Val::from(Tcp::new(123, 456));
    let b = Val::Nil;
    assert!(a != b);
}

#[test]
fn obj_neq() {
    let a = Val::from(Tcp::new(123, 456));
    let b = Val::from(Tcp::new(123, 455));
    assert!(a != b);
}

#[test]
fn obj_neq_type() {
    let a = Val::from(Tcp::new(123, 456));
    let b = Val::from(Udp::new());
    assert!(a != b);
}

#[test]
fn method_lookup() {
    let a = Val::from(Tcp::new(123, 456));
    assert_eq!(
        a.lookup_symbol("client_message"),
        Ok(Symbol::Val(ValDef::from(1)))
    );
}

#[test]
fn method_lookup_fail() {
    let a = Val::from(Tcp::new(123, 456));
    assert_eq!(a.lookup_symbol("client_massage"), Err(NameError));
}

#[test]
fn method_lookup_nil() {
    let a = Val::Nil;
    assert_eq!(a.lookup_symbol("client_massage"), Err(TypeError));
}

#[test]
fn downcast() {
    let a = ObjRef::from(Tcp::new(123, 456));
    let obj_ref = a.borrow();
    let b: &Tcp = obj_ref.as_any().downcast_ref().unwrap();

    assert_eq!(&Tcp::new(123, 456), b);
}

#[test]
fn mut_downcast() {
    let a = ObjRef::from(Tcp::new(123, 456));
    let mut obj_ref = a.borrow_mut();
    let b: &mut Tcp = obj_ref.as_mut_any().downcast_mut().unwrap();

    b.cl_seq = 111;
    b.sv_seq = 222;

    assert_eq!(Tcp::new(111, 222), *b);
}