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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use std::collections::BTreeMap;
use std::env;

use asterix_parser::asterix::category::CategoryKey;
use asterix_parser::asterix::message::parser::parse_message;
use asterix_parser::asterix::uap::common::dataitems::get_bitvec_subset_as_msb0;
use asterix_parser::asterix::uap::common::dataitems::get_msb_bits;
use asterix_parser::asterix::uap_json::structures::Attribute;
use asterix_parser::asterix::uap_json::structures::DataRecord;
use asterix_parser::asterix::uap_json::structures::Edition;
use bitvec::prelude::*;

use asterix_parser::asterix::category::CategoryIndex;
use asterix_parser::asterix::message::cat048;
use asterix_parser::asterix::message::AsterixMessage;
use asterix_parser::asterix::uap::providers::Provider;
use asterix_parser::asterix::Context;

#[test]
fn it_parse_cat048_message() -> anyhow::Result<()> {

    let curdir = env::current_dir().unwrap();
    println!("Running test from folder: {:?}", curdir.to_str());

    let mut message_bytes: Vec<u8> = vec![];
    message_bytes.append(&mut vec![0x30, 0x00, 0x30, 0xFD, 
                                   0xF7, 0x02, 0x19, 0xC9,
                                   0x35, 0x6D, 0x4D, 0xA0, 
                                   0xC5, 0xAF, 0xF1, 0xE0, 
                                   0x02, 0x00, 0x05, 0x28, 
                                   0x3C, 0x66, 0x0C, 0x10, 
                                   0xC2, 0x36, 0xD4, 0x18, 
                                   0x20, 0x01, 0xC0, 0x78, 
                                   0x00, 0x31, 0xBC, 0x00, 
                                   0x00, 0x40, 0x0D, 0xEB, 
                                   0x07, 0xB9, 0x58, 0x2E, 
                                   0x41, 0x00, 0x20, 0xF5]); 

    let explanatory_message = cat048::get_example_message();
    assert_eq!(message_bytes, explanatory_message);

    let asterix_context = Context::new()?;
    let cat_key = CategoryKey {
        index: CategoryIndex::_048,
        edition: Edition { major: 1, minor: 31 },
        provider: Provider::Standard
    };

    assert!(asterix_context.uap_definitions.contains_key(&cat_key), "UAP definitions should contains one CAT048 entry");

    let uap_048_collection: Vec<_> = asterix_context.uap_definitions.keys()
    .into_iter()
    .filter(|x| x.index == CategoryIndex::_048).collect();

    assert_eq!(true, uap_048_collection.len() > 0, "CAT048 definition should be greather than 0");
    assert_eq!(true, uap_048_collection.into_iter().filter(| p | p.provider == Provider::Standard).count() > 0);

    let cat048_uap_def_opt: Option<(CategoryKey, DataRecord)> 
        = asterix_context.uap_definitions
                .into_iter()
                .find(|x| x.0 == cat_key);
    assert_eq!(true, cat048_uap_def_opt.is_some(), "Should have found an UAP definiton for CAT048, provider == Standard");

    let cat048_uap_definition = cat048_uap_def_opt.unwrap().1;
    assert_eq!(28, cat048_uap_definition.catalogue.len(), "Should have 28 data item entries");

    let debugging: bool = false; 
    let _message =  parse_message(&cat048_uap_definition, &message_bytes, debugging);
    
    /*
    assert_eq!("CAT048", message.code);
    assert_eq!(Provider::Standard.as_ref(), message.provider);
    assert_eq!(13, message.data_items_store.len());
    assert_eq!(50, message.attributes.len());
    */
    //    assert_attributes(&message);

    Ok(())
    // check_attributes(&message, &message_bytes);
    //assert_eq!(true, message.code(&CategoryIndex::_048));
}

/* fn check_attributes(message: &AsterixMessage, message_bytes: &Vec<u8>) {
    for attribute in message.attributes.values() {
        get_bitvector_from_message(attribute, message_bytes);
        let key = &attribute.field_key;
        let elements: Vec<&str> = key.split("_").collect();
        let category_index = CategoryIndex::from_str(&elements[0][1..]).unwrap();
        let data_item_index = DataItemIndex::from_str(elements[1]).unwrap();
        // println!("key: {}, elements: [0:{}]. [1:{}], [2:{}]", key, elements[0], elements[1], elements[2]);
        let data_item : &DataItem = uap_dataitems.into_iter()
            .filter(|x| x.data_item.category == category_index &&
                                       x.data_item.data_item_index == data_item_index).collect();

        let attribute_definitions = get_data_item_attributes(data_item.type_id).unwrap();
        
        let attribute_definition: AsterixAttribute = attribute_definitions.into_iter()
                                    .filter(|x| x.name == elements[2]).collect();
         
            
    }
} */

fn _assert_attributes(message: &AsterixMessage) {
    // I048_010
    let attributes = &message.attributes_map;

    // I048_010
    let i048_010_octets = vec![0x19 as u8, 0xC9];
    _assert_eq_attribute_bitvec_value(&i048_010_octets, &attributes, "I048_010_sac", 16, 9);
    _assert_eq_attribute_bitvec_value(&i048_010_octets, &attributes, "I048_010_sic", 8, 1);

    // I048_020
    // todo: not sure about bit order, need to check and occasionaly change test code
    let i048_020_octets = vec![0xA0 as u8];
    _assert_eq_attribute_bitvec_value(&i048_020_octets, &attributes, "I048_020_typ", 8, 6);
    _assert_eq_attribute_bitvec_value(&i048_020_octets, &attributes, "I048_020_sim", 5, 5);
    _assert_eq_attribute_bitvec_value(&i048_020_octets, &attributes, "I048_020_rdp", 4, 4);
    _assert_eq_attribute_bitvec_value(&i048_020_octets, &attributes, "I048_020_spi", 3, 3);
    _assert_eq_attribute_bitvec_value(&i048_020_octets, &attributes, "I048_020_rab", 2, 2);

    // I048_140
    let i048_140_octets = vec![0x35 as u8, 0x6D, 0x4D];
    _assert_eq_attribute_bitvec_value(&i048_140_octets, &attributes, "I048_140_time_of_day", 24, 1);

    // I048_230
    let i048_230_octets = vec![0x20 as u8, 0xF5];
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_com", 16, 14);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_stat", 13, 11);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_si", 10, 10);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_mssc", 8, 8);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_mssc", 8, 8);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_arc", 7, 7);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_aic", 6, 6);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_b1a", 5, 5);
    _assert_eq_attribute_bitvec_value(&i048_230_octets, &attributes, "I048_230_b1b", 4, 1);

    // todo: check other attributes? Or an amostrage is good enough
}

fn _assert_eq_attribute_bitvec_value(octets: &Vec<u8>, attributes: &BTreeMap<String, Attribute>,attr_key: &str, msb_index: usize, lsb_index: usize) {
    let octets_bits = _get_expected_bits_from_u8_vec(octets);
    let expected_bits = get_bitvec_subset_as_msb0(&octets_bits, msb_index, lsb_index);
    let attribute = attributes.get(attr_key).unwrap(); 
    assert_eq!(expected_bits, attribute.bits, "{} bits should match", attr_key);
}

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
}