toad-msg 0.19.0

Low-level CoAP message parsing & serialization
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

use std::collections::BTreeMap;

use tinyvec::ArrayVec;
use toad_msg::*;

#[path = "common.rs"]
mod common;
use common::*;

#[derive(Debug, PartialEq, PartialOrd, Ord, Eq)]
pub struct TestInput {
  pub tkl: u8,
  pub n_opts: usize,
  pub opt_size: usize,
  pub payload_size: usize,
}

impl TestInput {
  pub fn get_bytes(&self) -> Vec<u8> {
    self.get_alloc_message().try_into_bytes::<Vec<_>>().unwrap()
  }
  pub fn get_alloc_message(&self) -> alloc::Message {
    self.into()
  }
  pub fn get_no_alloc_message<const P: usize, const N: usize, const O: usize>(
    &self)
    -> StackMessage<P, N, O> {
    self.into()
  }
  pub fn get_coap_lite_packet(&self) -> coap_lite::Packet {
    coap_lite::Packet::from_bytes(&self.get_bytes()).unwrap()
  }
}

impl<'a> From<&'a TestInput> for alloc::Message {
  fn from(inp: &'a TestInput) -> alloc::Message {
    let opts: BTreeMap<_, _> = (0..inp.n_opts).map(|n| {
                                                (OptNumber(n as u32),
                                  vec![OptValue(core::iter::repeat(1).take(inp.opt_size)
                                                                     .collect())])
                                              })
                                              .collect();

    let token = core::iter::repeat(1u8).take(inp.tkl as _)
                                       .collect::<tinyvec::ArrayVec<[_; 8]>>();

    alloc::Message { id: Id(1),
                     ty: Type::Non,
                     ver: Default::default(),
                     token: Token(token),
                     code: Code { class: 2,
                                  detail: 5 },
                     opts,
                     payload: Payload(core::iter::repeat(1u8).take(inp.payload_size).collect()) }
  }
}

impl<'a, const P: usize, const N: usize, const O: usize> From<&'a TestInput>
  for StackMessage<P, N, O>
{
  fn from(inp: &'a TestInput) -> StackMessage<P, N, O> {
    let opts: ArrayVec<[_; N]> =
      (0..inp.n_opts).map(|n| {
                       (OptNumber(n as u32),
                        tinyvec::array_vec![_ => OptValue(core::iter::repeat(1).take(inp.opt_size)
                                                                         .collect())])
                     })
                     .collect();

    let token = core::iter::repeat(1u8).take(inp.tkl as _)
                                       .collect::<tinyvec::ArrayVec<[_; 8]>>();

    StackMessage { id: Id(1),
                   ty: Type::Non,
                   ver: Default::default(),
                   token: Token(token),
                   code: Code { class: 2,
                                detail: 5 },
                   opts,
                   payload: Payload(core::iter::repeat(1u8).take(inp.payload_size).collect()) }
  }
}