bitis_lib/
lib.rs

1// #![feature(trace_macros)]
2//
3// trace_macros!(true);
4//
5
6pub mod msg_test;
7pub mod lib_impl;
8
9pub use lib_impl::berde::*;
10pub use lib_impl::compiler::*;
11pub use bitis_macros::{BiserdiMsg, BiserdiOneOf, BiserdiEnum};
12pub use std::result;
13
14
15
16pub fn serialize<T: BiserdiTrait>(data: &T) -> (Vec<u8>, BiserSizes){
17    let mut ser = Biseri::new();
18
19    data.bit_serialize(&mut ser);
20    let r = ser.finish_add_data().unwrap();
21    // println!("bits: {}, bytes: {}", r.total_bits, r.total_bytes);
22
23    (ser.get_data().to_owned(), r)
24}
25pub fn deserialize<T: BiserdiTrait>(data: &Vec<u8>) -> Option<(T, BiserSizes)> {
26    let mut der = Bides::from_vec(data);
27
28    let (v, bits) = T::bit_deserialize(1, &mut der)?;
29    let bytes_num = (bits >> 3) + if bits & 7 != 0 { 1 } else { 0 };
30    Some((v, BiserSizes{total_bits: bits, total_bytes: bytes_num}))
31}
32
33
34
35#[derive(Debug)]
36pub enum MessageManagerError {
37    InvalidMessage,
38}
39pub trait MessageWithHeaderTrait : Default {
40    fn serialize_header(&mut self, payload_size: usize, biseri: &mut Biseri) -> Option<u64>;
41    fn serialize_payload(&self, biseri: &mut Biseri) -> Option<u64>;
42    #[allow(unused_variables)]
43    fn post_serialization_callback(&mut self, header_size: usize, serialize_data: Vec<u8>) -> Vec<u8> { serialize_data }
44    fn deserialize_header(&mut self, data: &mut Bides) -> Result<Option<(usize, usize)>, MessageManagerError>;
45    fn deserialize_payload(&mut self, data: &mut Bides) -> Option<usize>;
46    fn pre_deserialization_callback(&mut self) {}
47}
48#[derive(Debug, Clone)]
49pub struct MessageManager<MWH> {
50    pub bides: Bides,
51    pub data_unused: Vec<u8>,
52    pub header_successfully_read: bool,
53
54    pub payload_size: usize,
55    pub msg_with_header: MWH,
56}
57#[allow(unused)]
58impl<MWH: MessageWithHeaderTrait + Default> MessageManager<MWH> {
59    pub fn create() -> Self {
60        Self{bides: Bides::new(), data_unused: Vec::new(), header_successfully_read: false,
61            payload_size: 0, msg_with_header: Default::default(), }
62    }
63
64    pub fn bit_serialize(&mut self) -> Vec<u8> {
65        let mut biseri_payload =  Biseri::new();
66        self.msg_with_header.serialize_payload(&mut biseri_payload);
67        let rp = biseri_payload.finish_add_data().unwrap();
68        self.payload_size = rp.total_bytes as usize;
69        
70        let mut biseri_header =  Biseri::new();
71        self.msg_with_header.serialize_header(rp.total_bytes as usize, &mut biseri_header);
72        let header_size = biseri_header.finish_add_data().unwrap();
73        
74        let mut data = biseri_header.get_data();
75        data.extend(biseri_payload.get_data());
76
77        self.msg_with_header.post_serialization_callback(header_size.total_bytes as usize, data)
78    }
79
80    pub fn append_data_and_try_deserialize(&mut self, data: &Vec<u8>) -> Result<Option<usize>, MessageManagerError> {
81        self.bides.append_data(data);
82
83        if !self.header_successfully_read {
84            if self.bides.data_cache.len() == 0 { return Ok(None); }
85
86            let (p, b) = match self.msg_with_header.deserialize_header(&mut self.bides)? {
87                None => { return Ok(None); } Some(v) => { v }
88            };
89            self.payload_size = p;
90            self.header_successfully_read = true;
91            self.bides.data_cache.drain(..b);
92            self.bides.reset_position();
93        }
94        if self.header_successfully_read {
95            if self.bides.data_cache.len() < self.payload_size { return Ok(None); }
96            if self.bides.data_cache.len() > self.payload_size {
97                self.data_unused.extend(self.bides.data_cache[self.payload_size..].to_vec());
98                self.bides.data_cache.truncate(self.payload_size);
99            }
100
101            match self.msg_with_header.deserialize_payload(&mut self.bides) {
102                Some(s) => Ok(Some(s)), None => Ok(None)
103            }
104        }
105        else { Ok(None) }
106    }
107
108    pub fn clear(& mut self) {
109        self.bides = Bides::new(); self.data_unused = Vec::new();
110        self.header_successfully_read = false; self.payload_size = 0;
111        self.msg_with_header = Default::default();
112    }
113}
114
115
116#[cfg(test)]
117mod msg_manager_test {
118    use rstest::rstest;
119    use super::*;
120
121    #[derive(BiserdiMsg, Debug, Clone, PartialEq, Default)]
122    struct MsgHeaderByteTwo {
123        size_high: IntWithGivenBitSize<u8, 6>,
124        must_be_one: IntWithGivenBitSize<u8, 2>,
125    }
126    #[derive(BiserdiMsg, Debug, Clone, PartialEq, Default)]
127    struct MsgHeader {
128        size_low: IntWithGivenBitSize<u8, 6>,
129        must_be_one: IntWithGivenBitSize<u8, 1>,
130        byte_two: BitisOption<MsgHeaderByteTwo>
131    }
132    #[derive(BiserdiMsg, Debug, Clone, PartialEq, Default)]
133    struct MsgLalaBase {
134        a1: IntWithGivenBitSize<u16, 13>,
135        b1: bool,
136        b2: bool,
137        f: f32,
138    }
139
140    #[derive(Debug, Clone, PartialEq, Default)]
141    struct MsgWH{
142        header: MsgHeader,
143        payload: MsgLalaBase,
144    }
145    impl MessageWithHeaderTrait for MsgWH {
146        fn serialize_header(&mut self, payload_size: usize, biseri: &mut Biseri) -> Option<u64> {
147            let payload_size_high = (payload_size>>6) as u8;
148            self.header = MsgHeader{
149                size_low: ((payload_size & ((1<<6)-1)) as u8).into(),
150                must_be_one: 1.into(),
151                byte_two: if payload_size_high > 0 {
152                    Some(MsgHeaderByteTwo{size_high: payload_size_high.into(), must_be_one: 1.into() }).into() }
153                else { BitisOption::<MsgHeaderByteTwo>{val: None} }
154            };
155            self.header.bit_serialize(biseri)
156        }
157
158        fn serialize_payload(&self, biseri: &mut Biseri) -> Option<u64> {
159            self.payload.bit_serialize(biseri)
160        }
161
162        fn deserialize_header(&mut self, bides: &mut Bides) -> Result<Option<(usize, usize)>, MessageManagerError> {
163            let bit_size = match MsgHeader::bit_deserialize(0, bides) {
164                None => {
165                    bides.reset_position();
166                    return Ok(None)
167                }
168                Some((h, r)) => {
169                    self.header = h;
170                    r
171                }
172            };
173            if self.header.must_be_one.val != 1 { return Err(MessageManagerError::InvalidMessage) }
174            if let Some(v) = self.header.byte_two.clone().val {
175                if v.must_be_one.val != 1 { return Err(MessageManagerError::InvalidMessage) }
176            }
177            Ok(Some(
178                (
179                    (self.header.size_low.val as usize) +
180                        if let Some(bt) = self.header.byte_two.clone().val
181                        { (bt.size_high.val as usize) << 6 } else { 0 },
182                    (bit_size >> 3) as usize
183                )
184            ))
185        }
186
187        fn deserialize_payload(&mut self, bides: &mut Bides) -> Option<usize> {
188            match MsgLalaBase::bit_deserialize(0, bides) {
189                None => { bides.reset_position(); None }
190                Some((p, s)) => {
191                    self.payload = p;
192                    Some(s as usize)
193                }
194            }
195        }
196    }
197    #[rstest]
198    fn msg_manager_simple() {
199        let payload = MsgLalaBase{ a1: 1234.into(), b1: false, b2: true, f: 12.34 };
200        let mut s1 = Biseri::new();
201        payload.bit_serialize(&mut s1);
202        s1.finish_add_data().unwrap();
203        let s = s1.get_data().len();
204
205        let header = MsgHeader{
206            size_low: ((s & ((1<<6)-1)) as u8).into(),
207            must_be_one: 1.into(),
208            byte_two: if (s>>6) > 0 {
209                Some(MsgHeaderByteTwo{size_high: ((s>>6) as u8).into(), must_be_one: 1.into() }).into() }
210            else { BitisOption::<MsgHeaderByteTwo>{val: None} }
211        };
212        let mut s2 = Biseri::new();
213        header.bit_serialize(&mut s2);
214        s2.finish_add_data().unwrap();
215        let mut data = s2.get_data();
216        data.extend(s1.get_data());
217
218        let mut mm = MessageManager::<MsgWH>::create();
219        let r = mm.append_data_and_try_deserialize(&vec![data[0]]);
220        assert!(r.is_ok());
221        let r = r.unwrap();
222        assert!(r.is_none());
223
224        let r = mm.append_data_and_try_deserialize(&data[1..].to_vec());
225        assert!(r.is_ok());
226        let r = r.unwrap();
227        assert!(r.is_some());
228
229        println!("{:#?}", mm);
230        assert_eq!(mm.msg_with_header.header, header);
231        assert_eq!(mm.msg_with_header.payload, payload);
232    }
233    #[rstest]
234    fn msg_manager_full() {
235        let mut mm_ser = MessageManager::<MsgWH>::create();
236
237        mm_ser.msg_with_header.payload = MsgLalaBase{ a1: 1234.into(), b1: false, b2: true, f: 12.34 };
238        let data = mm_ser.bit_serialize();
239        println!("{:#?}", mm_ser);
240        println!("data len: {}", data.len());
241        
242        let mut mm_des = MessageManager::<MsgWH>::create();
243        let r = mm_des.append_data_and_try_deserialize(&vec![data[0]]);
244        assert!(r.is_ok());
245        let r = r.unwrap();
246        assert!(r.is_none());
247
248        let r = mm_des.append_data_and_try_deserialize(&data[1..].to_vec());
249        assert!(r.is_ok());
250        let r = r.unwrap();
251        assert!(r.is_some());
252
253        println!("{:#?}", mm_des);
254        assert_eq!(mm_des.msg_with_header.header, mm_ser.msg_with_header.header);
255        assert_eq!(mm_des.msg_with_header.payload, mm_ser.msg_with_header.payload);
256    }
257}
258
259#[cfg(test)]
260mod msg_deserialization {
261    use rstest::rstest;
262    use super::*;
263
264    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
265    struct MsgLalaBase {
266        a1: IntWithGivenBitSize<u16, 13>,
267        b1: bool,
268        b2: bool,
269        f: f32,
270    }
271
272    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
273    struct MsgLili {
274        inner_msg: MsgLalaBase,
275        b1: bool,
276        b2: IntWithGivenBitSize<u8, 7>,
277        signed: IntWithGivenBitSize<i8, 4>,
278    }
279
280    #[rstest]
281    fn msg_simple_msg_serde() {
282        let mut ser = Biseri::new();
283
284        let m = MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 };
285        println!("m: {:?}", m);
286
287        m.bit_serialize(&mut ser);
288        let r = ser.finish_add_data().unwrap();
289        let (bits, bytes) = (r.total_bits, r.total_bytes);
290        println!("bits: {}, bytes: {}", bits, bytes);
291
292        // ***
293        let mut der = Bides::from_biseri(&ser);
294
295        let mm = MsgLalaBase::bit_deserialize(1, &mut der);
296        assert!(mm.is_some());
297        let mm = mm.unwrap();
298        println!("mm: {:?}", mm);
299
300        assert_eq!(m, mm.0);
301    }
302
303    #[rstest]
304    fn msg_with_inner_msg_serde() {
305        let mut ser = Biseri::new();
306
307        let m = MsgLili {
308            inner_msg: MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 },
309            b1: true,
310            b2: 11.into(),
311            signed: (-3).into()
312        };
313        println!("m: {:?}", m);
314
315        m.bit_serialize(&mut ser);
316        let r = ser.finish_add_data().unwrap();
317        let (bits, bytes) = (r.total_bits, r.total_bytes);
318        println!("bits: {}, bytes: {}", bits, bytes);
319
320        // ***
321        let mut der = Bides::from_biseri(&ser);
322
323        let mm = MsgLili::bit_deserialize(1, &mut der);
324        assert!(mm.is_some());
325        let mm = mm.unwrap();
326        println!("mm: {:?}", mm);
327
328        assert_eq!(m, mm.0);
329    }
330
331    #[derive(BiserdiOneOf, Debug, Clone, PartialEq)]
332    #[biserdi_enum_id_dynbits(4)]
333    enum OOLili {
334        InnerMsg(MsgLalaBase),
335        B1(bool),
336        F2(f32),
337        //#[biserdi_enum_id_bits(22)]
338        Signed(IntWithGivenBitSize<i8, 6>),
339    }
340
341    fn oneof_test_serde(m: OOLili) {
342        println!("m: {:?}", m);
343
344        let mut ser = Biseri::new();
345
346        m.bit_serialize(&mut ser);
347        let r = ser.finish_add_data().unwrap();
348        let (bits, bytes) = (r.total_bits, r.total_bytes);
349        println!("bits: {}, bytes: {}", bits, bytes);
350
351        // ***
352        let mut der = Bides::from_biseri(&ser);
353
354        let mm = OOLili::bit_deserialize(1, &mut der);
355        assert!(mm.is_some());
356        let mm = mm.unwrap();
357        println!("mm: {:?}", mm);
358
359        assert_eq!(bits, mm.1);
360        assert_eq!(m, mm.0);
361    }
362    #[rstest]
363    fn oneof_msg_serde() {
364        let m = OOLili::InnerMsg(MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 });
365        oneof_test_serde(m);
366    }
367    #[rstest]
368    fn oneof_bool_serde() {
369        let m = OOLili::B1(true);
370        oneof_test_serde(m);
371    }
372    #[rstest]
373    fn oneof_f32_serde() {
374        let m = OOLili::F2(98765.54321);
375        oneof_test_serde(m);
376    }
377    #[rstest]
378    fn oneof_var_with_given_bit_size_serde() {
379        let m = OOLili::Signed((-3).into());
380        oneof_test_serde(m);
381    }
382
383    #[derive(BiserdiEnum, Debug, Clone, PartialEq)]
384    #[biserdi_enum_id_dynbits(4)]
385    #[allow(nonstandard_style)]
386    enum EnumLele {
387        One,
388        Two,
389        Three
390    }
391    // impl std::fmt::Display for EnumLele {
392    //     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self) }
393    // }
394    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
395    struct MsgLalaEnum {
396        e1: EnumLele,
397        b1: bool,
398        b2: bool,
399    }
400
401    #[rstest]
402    fn enum_msg_serde() {
403        let mut ser = Biseri::new();
404
405        let msg = MsgLalaEnum{
406            e1: EnumLele::Two,
407            b1: true,
408            b2: false,
409        };
410        msg.bit_serialize(&mut ser);
411        let r = ser.finish_add_data().unwrap();
412        let (bits, bytes) = (r.total_bits, r.total_bytes);
413        println!("bits: {}, bytes: {}", bits, bytes);
414
415        // ***
416        let mut der = Bides::from_biseri(&ser);
417
418        let mm = MsgLalaEnum::bit_deserialize(1, &mut der);
419        assert!(mm.is_some());
420        let mm = mm.unwrap();
421        println!("mm: {:?}", mm);
422
423        assert_eq!(bits, mm.1);
424        assert_eq!(msg, mm.0);
425    }
426
427}
428
429#[cfg(test)]
430mod msg_deserialization_ver {
431    use rstest::rstest;
432    use super::*;
433    pub use bitis_macros::{BiserdiMsgVersioned};
434
435    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
436    struct MsgLalaBase {
437        a1: IntWithGivenBitSize<u16, 13>,
438        b1: bool,
439        b2: bool,
440        f: f32,
441    }
442
443    // ***
444    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
445    struct MsgLalaV1 {}
446    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
447    struct MsgLalaExtV1 {
448        v1: MsgLalaV1
449    }
450    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
451    struct MsgLalaVersionedV1 {
452        base: MsgLalaBase,
453        ext: MsgLalaExtV1
454    }
455    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
456    #[allow(nonstandard_style)]
457    struct MsgLala_V2 {
458        e1: IntWithGivenBitSize<i8, 4>,
459        e2: bool,
460    }
461    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
462    #[allow(nonstandard_style)]
463    struct MsgLala_ExtV2 {
464        v1: MsgLalaV1,
465        v2: MsgLala_V2
466    }
467    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
468    struct MsgLalaVersionedV2 {
469        base: MsgLalaBase,
470        ext: MsgLala_ExtV2
471    }
472    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
473    struct MsgLalaV3 {}
474    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
475    #[allow(nonstandard_style)]
476    struct MsgLala_ExtV3 {
477        v1: MsgLalaV1,
478        v2: MsgLala_V2,
479        v3: MsgLalaV3
480    }
481    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
482    struct MsgLalaVersionedV3 {
483        base: MsgLalaBase,
484        ext: MsgLala_ExtV3
485    }
486    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
487    struct MsgLalaV4 {
488        ee1: bool,
489        ee2: bool,
490        ee3: IntWithGivenBitSize<i16, 14>,
491    }
492    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
493    struct MsgLalaExtV4 {
494        v1: MsgLalaV1,
495        v2: MsgLala_V2,
496        v3: MsgLalaV3,
497        v4: MsgLalaV4
498    }
499    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
500    struct MsgLalaVersionedV4 {
501        base: MsgLalaBase,
502        ext: MsgLalaExtV4
503    }
504    #[rstest]
505    // test backwards compability
506    fn encode_v2_decode_v1() {
507        let mut ser = Biseri::new();
508
509        let m = MsgLalaVersionedV2 {
510            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
511            ext: MsgLala_ExtV2 { v1: MsgLalaV1 {}, v2: MsgLala_V2 { e1: (-6).into(), e2: true } }
512        };
513        m.bit_serialize(&mut ser);
514        println!("m: {:?}", m);
515
516        let r = ser.finish_add_data().unwrap();
517        let (bits, bytes) = (r.total_bits, r.total_bytes);
518        println!("bits: {}, bytes: {}", bits, bytes);
519
520        // ***
521        let mut der = Bides::from_biseri(&ser.clone());
522
523        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
524        println!("v2 - mm: {:?}", mm);
525        assert!(mm.is_some());
526        let mm = mm.unwrap();
527
528        assert_eq!(bits, mm.1);
529        assert_eq!(m, mm.0);
530
531        // ***
532        let mut der = Bides::from_biseri(&ser);
533
534        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
535        println!("v1 - mm: {:?}", mm);
536        assert!(mm.is_some());
537        let mm = mm.unwrap();
538
539        assert_eq!(bits, mm.1);
540        assert_eq!(m.base, mm.0.base);
541    }
542    #[rstest]
543    fn encode_v3_decode_v2_and_v1() {
544        let mut ser = Biseri::new();
545
546        let m = MsgLalaVersionedV4 {
547            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
548            ext: MsgLalaExtV4 {
549                v1: MsgLalaV1 {},
550                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
551                v3: MsgLalaV3 {},
552                v4: MsgLalaV4 { ee1: false, ee2: true, ee3: (-5678).into(), }
553            }
554        };
555
556        m.bit_serialize(&mut ser);
557        println!("m: {:?}", m);
558
559        let r = ser.finish_add_data().unwrap();
560        let (bits, bytes) = (r.total_bits, r.total_bytes);
561        println!("bits: {}, bytes: {}", bits, bytes);
562
563        // ***
564        let mut der = Bides::from_biseri(&ser.clone());
565
566        let mm = MsgLalaVersionedV4::bit_deserialize(1, &mut der);
567        println!("v3 - mm: {:?}", mm);
568        assert!(mm.is_some());
569        let mm = mm.unwrap();
570
571        assert_eq!(bits, mm.1);
572        assert_eq!(m, mm.0);
573
574        // ***
575        let mut der = Bides::from_biseri(&ser.clone());
576
577        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
578        println!("v2 - mm: {:?}", mm);
579        assert!(mm.is_some());
580        let mm = mm.unwrap();
581
582        assert_eq!(bits, mm.1);
583        assert_eq!(m.base, mm.0.base);
584        assert_eq!(m.ext.v2, mm.0.ext.v2);
585
586        // ***
587        let mut der = Bides::from_biseri(&ser);
588
589        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
590        println!("v1 - mm: {:?}", mm);
591        assert!(mm.is_some());
592        let mm = mm.unwrap();
593
594        assert_eq!(bits, mm.1);
595        assert_eq!(m.base, mm.0.base);
596    }
597
598    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
599    enum MsgLalaVersionEnum {
600        V1(MsgLalaVersionedV1),
601        V2(MsgLalaVersionedV2),
602        V3(MsgLalaVersionedV3),
603        V4(MsgLalaVersionedV4),
604    }
605    #[rstest]
606    fn encode_v3_decode_v2_and_v4() {
607        let mut ser = Biseri::new();
608
609        let mv = MsgLalaVersionedV3 {
610            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
611            ext: MsgLala_ExtV3 {
612                v1: MsgLalaV1 {},
613                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
614                v3: MsgLalaV3 {},
615            }
616        };
617        let m = MsgLalaVersionEnum::V3(mv.clone());
618
619        m.bit_serialize(&mut ser);
620        println!("m: {:?}", m);
621
622        let r = ser.finish_add_data().unwrap();
623        let (bits, bytes) = (r.total_bits, r.total_bytes);
624        println!("bits: {}, bytes: {}", bits, bytes);
625
626        // ***
627        let mut der = Bides::from_biseri(&ser.clone());
628
629        let mm = MsgLalaVersionEnum::bit_deserialize(2, &mut der);
630        println!("v2 - mm: {:?}", mm);
631        assert!(mm.is_some());
632        let mm = mm.unwrap();
633
634        let mmm = match mm.0.clone() {
635            MsgLalaVersionEnum::V2(v) => v, _ => { panic!("Wrong enum, expected v2") }
636        };
637
638
639        assert_eq!(bits, mm.1);
640        assert_eq!(mv.base, mmm.base);
641        assert_eq!(mv.ext.v1, mmm.ext.v1);
642        assert_eq!(mv.ext.v2, mmm.ext.v2);
643
644        // ***
645        let mut der = Bides::from_biseri(&ser.clone());
646
647        let mm = MsgLalaVersionEnum::bit_deserialize(3, &mut der);
648        println!("v4 - mm: {:?}", mm);
649        assert!(mm.is_some());
650        let mm = mm.unwrap();
651
652        let mmm = match mm.0.clone() {
653            MsgLalaVersionEnum::V3(v) => v, _ => { panic!("Wrong enum, expected v3") }
654        };
655
656        assert_eq!(bits, mm.1);
657        assert_eq!(mv.base, mmm.base);
658        assert_eq!(mv.ext.v2, mmm.ext.v2);
659        assert_eq!(mv.ext.v3, mmm.ext.v3);
660    }
661}
bitis_lib/lib.rs

bitis_lib/
lib.rs
