asterix_parser 0.1.1

Playground do Protocolo ASTERIX
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

use std::fmt;

use asterix_parser::asterix::uap::common::dataitems::{get_bitvec_subset_as_msb0, get_msb_bits};
use bitvec::prelude::*;

#[test]
pub(crate) fn test_bitvec() {
    let mut bv: BitVec = BitVec::new();
    bv.push(false);
    bv.push(true);
    bv.push(false);
    bv.push(false);
    bv.push(false);
    bv.push(false);
    bv.push(false);
    bv.push(false);

    assert_eq!(bv.len(), 8);
    assert_eq!(bv[0], false);

    // assert_eq!(bv.pop(), Some(true));
    // assert_eq!(bv.len(), 1);

    let mut bv_m = bitvec![u16, Msb0;];
    bv_m.push(false);
    bv_m.push(true);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);

    let mut bv_l = bitvec![u16, Lsb0;];
    bv_l.push(false);
    bv_l.push(true);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);

    println!("bv {}, bv_m {}, bv_l {}", bv, bv_m, bv_l);
    println!("bv {}, bv_m {}, bv_l {}", bv, bv_m, bv_l);

    print!("bv positions: ");
    for i in 0..8 {
        print!("{}", if bv[i] { "1" } else { "0" }); 
    }
    println!();

    print!("bv_m positions: ");
    for i in 0..8 {
        print!("{}", if bv_m[i] { "1" } else { "0" }); 
    }
    println!();

    print!("bv_l positions: ");
    for i in 0..8 {
        print!("{}", if bv_l[i] { "1" } else { "0" }); 
    }
    println!();

    let can_id: &[_] = &[0b10100000 as u8];
    // let mut can_id_bits = can_id.view_bits::<Msb0>().to_bitvec();
    let can_id_bits = get_msb_bits(&can_id);

    // used to debug
    // use std::fmt;
    // let strip_characters = &['[',']',' ',','];
    // let can_id_bits_str = fmt::format(format_args!("{0:b}", can_id_bits)).replace(strip_characters, "");

    assert_eq!(can_id_bits[0], true,  "bit 7 should be true");
    assert_eq!(can_id_bits[1], false, "bit 6 should be false");
    assert_eq!(can_id_bits[2], true,  "bit 5 should be true");
    assert_eq!(can_id_bits[7], false, "bit 0 should be false");
}

#[test]
pub(crate) fn test_bitvec_from_u8_vec() {

    let source = vec![0b1010_0101_u8, 0b11110000, 0b00001111];
    let bv: BitVec<u8, Msb0> = BitVec::<_, Msb0>::from_vec(source);
    
    let mut count = 0;
    println!("bv {}", bv);
    for bit in bv {
        println!("Bit {}: {}", count, bit);
        count += 1;
    }

}

#[test]
pub(crate) fn test_bitvec_split_off() {

    let mut bv = bitvec![0, 1, 0, 0, 1, 0, 0, 0];
    let bv2 = bv.split_off(2);
    assert_eq!((&*bv, &*bv2), (bits![0, 1], bits![0, 0, 1, 0, 0, 0]));

    let mut bv = bitvec![0, 1, 0, 0, 1, 0, 0, 0];
    let mut bv2 = bv.split_off(1);
    assert_eq!((&*bv, &*bv2), (bits![0], bits![1, 0, 0, 1, 0, 0, 0]));

    let bv3 = bv2.split_off(3);
    assert_eq!((&*bv2, &*bv3), (bits![1, 0, 0], bits![1, 0, 0, 0]));

    println!("Stringyfied {}", stringify!("Test"));
}

#[test]
pub(crate) fn test_bitvec_subset() {
    // I048_230
    // 0b00100000, 0b11110101

    let trim_characters: &[_]  = &['[', ']', ' ', ','][..];
    let octet_bits = get_expected_bits_from_u8_vec(&vec![0x20 as u8, 0xF5]); 
    
    let expected_bits = get_bitvec_subset_as_msb0(&octet_bits, 16, 14);
    let expected_bits_as_string = fmt::format(format_args!("{:b}", &expected_bits)).replace(trim_characters, "");

    let requested_subset = get_bitvec_subset_as_msb0(&octet_bits, 16, 14);
    let requested_subset_as_string = fmt::format(format_args!("{:b}", &requested_subset)).replace(trim_characters, "");

    println!("Expected  bits: {}", expected_bits_as_string);
    println!("Requested bits: {}", requested_subset_as_string);
    assert_eq!(expected_bits, requested_subset);
}

fn get_expected_bits_from_u8_vec(vec_u8: &Vec<u8>) -> BitVec<u8, Msb0> {
    // let mut bitvec = (vec_u8).view_bits::<Msb0>().to_bitvec();
    let bitvec = get_msb_bits(vec_u8.as_slice());
    bitvec
}