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

//! CBOR exact reader and writer
//!
//! ```
//! use cbored::Reader;
//! let mut reader = Reader::new(&[0x80]);
//! let array = reader.array().expect("valid array");
//! assert_eq!(array.len(), 0);
//! ```
//!
//! ```
//! use cbored::{Writer, StructureLength, Positive};
//! let mut writer = Writer::new();
//! writer.array_build(StructureLength::Indefinite, |writer| {
//!     writer.positive(Positive::canonical(10));
//! })

mod context;

mod reader;
mod writer;

mod decode;
mod encode;

pub mod tagged;

pub(crate) mod header;
mod lead;
pub mod state;
mod types;
pub mod validate;

pub use reader::{Reader, ReaderError};
pub use writer::Writer;

pub use decode::{Decode, DecodeError};
pub use encode::Encode;

pub use types::*;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test1() {
        let mut writer = Writer::new();
        writer.constant(Constant::True);
        let cbor = writer.finalize();

        let mut reader = Reader::new(&cbor);
        let con = reader.constant().unwrap();
        assert_eq!(reader.is_finished(), true);
        assert_eq!(con, Constant::True);
    }

    #[test]
    fn test2() {
        let mut writer = Writer::new();
        writer.constant(Constant::True);
        writer.positive(Positive::canonical(124));
        let cbor = writer.finalize();

        let mut reader = Reader::new(&cbor);
        let con = reader.constant().unwrap();
        let pos = reader.positive().unwrap();
        assert_eq!(reader.is_finished(), true);
        assert_eq!(con, Constant::True);
        assert_eq!(pos.to_u64(), 124);
    }

    #[test]
    fn test_err_reading_type() {
        let mut writer = Writer::new();
        writer.constant(Constant::True);
        writer.positive(Positive::canonical(124));
        let cbor = writer.finalize();

        let mut reader = Reader::new(&cbor);
        let con = reader.constant().unwrap();

        // try to read a different type than the expected positive should
        // error, and also not consume anything, so that the next correct reading
        // will work
        assert_eq!(reader.negative().is_err(), true);

        let pos = reader.positive().unwrap();
        assert_eq!(reader.is_finished(), true);
        assert_eq!(con, Constant::True);
        assert_eq!(pos.to_u64(), 124);
    }
}