diff --git a/Cargo.lock b/Cargo.lock index ff3431b..88007a2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -180,8 +180,7 @@ checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1" [[package]] name = "cbor_event" version = "2.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "089a0261d1bc59e54e8e11860031efd88593f0e61b921172c474f1f38c2f2d3c" +source = "git+https://github.com/primetype/cbor_event#2b6330abe7aa69d230454ea2cadda5015526e681" [[package]] name = "cc" diff --git a/Cargo.toml b/Cargo.toml index 9afce00..99f47ad 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ default = ["which-rustfmt"] which-rustfmt = ["which"] [dependencies] -cbor_event = "2.4.0" +cbor_event = { git = "https://github.com/primetype/cbor_event" } cddl = "0.9.1" clap = { version = "4.3.12", features = ["derive"] } codegen = { git = "https://github.com/dcSpark/codegen", branch = "master" } @@ -22,4 +22,4 @@ nom = "7.1.1" pathdiff = "0.2.1" which = { version = "4.4.0", optional = true, default-features = false } syn = "2.0.16" -quote = "1.0.31" \ No newline at end of file +quote = "1.0.31" diff --git a/example/serialization_unit_tests.rs b/example/serialization_unit_tests.rs index fcadfa1..d7c590a 100644 --- a/example/serialization_unit_tests.rs +++ b/example/serialization_unit_tests.rs @@ -3,9 +3,9 @@ mod tests { use super::*; use serialization::*; - fn print_cbor_types(obj_name: &str, vec: &Vec) { - use cbor_event::Type; - let mut raw = Deserializer::from(std::io::Cursor::new(vec)); + fn print_cbor_types(obj_name: &str, vec: Vec) { + use cbor_event::Type; + let mut raw = Deserializer::from(vec); println!("{} = {{", obj_name); loop { match raw.cbor_type() { @@ -24,9 +24,9 @@ mod tests { } fn deser_test(orig: T) { - print_cbor_types("orig", &orig.to_bytes()); - let deser = T::deserialize(&mut Deserializer::from(std::io::Cursor::new(orig.to_bytes()))).unwrap(); - print_cbor_types("deser", &deser.to_bytes()); + print_cbor_types("orig", orig.to_bytes()); + let deser = T::deserialize(&mut Deserializer::from(orig.to_bytes())).unwrap(); + print_cbor_types("deser", deser.to_bytes()); assert_eq!(orig.to_bytes(), deser.to_bytes()); } @@ -37,7 +37,10 @@ mod tests { #[test] fn foo2_some() { - deser_test(Foo2::new(143546, Some(TaggedText::new(String::from("afdjfkjsiefefe"))))); + deser_test(Foo2::new( + 143546, + Some(TaggedText::new(String::from("afdjfkjsiefefe"))), + )); } #[test] @@ -47,17 +50,26 @@ mod tests { #[test] fn bar() { - deser_test(Bar::new(&Foo::new(436, String::from("jfkdf"), vec![6, 4]), None)); + deser_test(Bar::new( + &Foo::new(436, String::from("jfkdf"), vec![6, 4]), + None, + )); } #[test] fn plain() { - deser_test(Plain::new(7576, &TaggedText::new(String::from("wiorurri34h")))); + deser_test(Plain::new( + 7576, + &TaggedText::new(String::from("wiorurri34h")), + )); } #[test] fn outer() { - deser_test(Outer::new(2143254, &Plain::new(7576, &TaggedText::new(String::from("wiorurri34h"))))); + deser_test(Outer::new( + 2143254, + &Plain::new(7576, &TaggedText::new(String::from("wiorurri34h"))), + )); } #[test] @@ -89,7 +101,7 @@ mod tests { fn type_choice_hello_world() { deser_test(TypeChoice::new_helloworld()); } - + #[test] fn type_choice_uint() { deser_test(TypeChoice::new_u64(53435364)); @@ -97,7 +109,9 @@ mod tests { #[test] fn type_choice_text() { - deser_test(TypeChoice::new_text(String::from("jdfidsf83j3 jkrjefdfk !!"))); + deser_test(TypeChoice::new_text(String::from( + "jdfidsf83j3 jkrjefdfk !!", + ))); } #[test] @@ -122,6 +136,9 @@ mod tests { #[test] fn group_choice_plain() { - deser_test(GroupChoice::new_plain(&Plain::new(354545, &TaggedText::new(String::from("fdsfdsfdg"))))); + deser_test(GroupChoice::new_plain(&Plain::new( + 354545, + &TaggedText::new(String::from("fdsfdsfdg")), + ))); } } diff --git a/src/generation.rs b/src/generation.rs index a78fc13..875a134 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -748,7 +748,10 @@ impl GenerationScope { // rust self.rust_lib() - .raw("#![allow(clippy::too_many_arguments)]\n"); + .raw("#![allow(clippy::too_many_arguments)]\n") + .raw("#![no_std]\n") + .raw("#![feature(error_in_core)]\n") + .raw("#![cfg_attr(not(test), no_std)]\n"); let codegen_comment = "// This file was code-generated using an experimental CDDL to rust tool:\n// https://github.com/dcSpark/cddl-codegen\n"; for content in self.rust_scopes.values_mut() { content.raw(codegen_comment); @@ -765,7 +768,16 @@ impl GenerationScope { // declare modules (root lib specific) if cli.export_static_files() { - self.rust_lib().raw("pub mod error;"); + self.rust_lib() + .raw("pub mod error;") + .raw("extern crate alloc;") + .raw("#[cfg(test)]\nextern crate std;") + .push_import("alloc::borrow", "ToOwned", None) + .push_import("alloc::boxed", "Box", None) + .push_import("alloc::string", "String", None) + .push_import("alloc::string", "ToString", None) + .push_import("alloc", "vec", None) + .push_import("alloc::vec", "Vec", None); if cli.preserve_encodings { self.rust_lib().raw("pub mod ordered_hash_map;"); } @@ -799,7 +811,10 @@ impl GenerationScope { for content in self.rust_scopes.values_mut() { // needed if there's any params that can fail content - .push_import("std::convert", "TryFrom", None) + .push_import("core::convert", "TryFrom", None) + .push_import("crate::error", "*", None) + .push_import("alloc::string", "String", None) + .push_import("alloc::vec", "Vec", None) .push_import(format!("{}::error", cli.common_import_rust()), "*", None); // in case we store these in enums we're just going to dump them in everywhere if cli.preserve_encodings { @@ -822,7 +837,8 @@ impl GenerationScope { // Issue (general - not just here): https://github.com/dcSpark/cddl-codegen/issues/139 for content in self.cbor_encodings_scopes.values_mut() { content - .push_import("std::collections", "BTreeMap", None) + .push_import("alloc::collections", "BTreeMap", None) + .push_import("alloc::vec", "Vec", None) .push_import( format!("{}::serialization", cli.common_import_rust()), "LenEncoding", @@ -903,7 +919,7 @@ impl GenerationScope { // TODO: we blindly add these two map imports. Ideally we would only do it when needed // but the code to figure that out would be potentially complex. // Issue (general - not just here): https://github.com/dcSpark/cddl-codegen/issues/139 - content.push_import("std::collections", "BTreeMap", None); + content.push_import("alloc::collections", "BTreeMap", None); if cli.preserve_encodings { content.push_import( format!("{}::ordered_hash_map", cli.common_import_rust()), @@ -918,10 +934,12 @@ impl GenerationScope { for (scope, content) in self.serialize_scopes.iter_mut() { content .push_import("super", "*", None) - .push_import("std::io", "BufRead", None) - .push_import("std::io", "Seek", None) - .push_import("std::io", "SeekFrom", None) - .push_import("std::io", "Write", None) + .push_import("alloc::borrow", "ToOwned", None) + .push_import("alloc::boxed", "Box", None) + .push_import("alloc", "fmt", None) + .push_import("alloc::string", "String", None) + .push_import("alloc::string", "ToString", None) + .push_import("alloc::vec", "Vec", None) .push_import("cbor_event::de", "Deserializer", None) .push_import("cbor_event::se", "Serializer", None) .push_import(format!("{}::error", cli.common_import_rust()), "*", None); @@ -1820,7 +1838,7 @@ impl GenerationScope { let mut key_order_sort_match = Block::new("match lhs_bytes.len().cmp(&rhs_bytes.len())"); key_order_sort_match - .line("std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),") + .line("core::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),") .line("diff_ord => diff_ord,"); key_order_sort.push_block(key_order_sort_match).after(");"); key_order_if.push_block(key_order_sort); @@ -2382,9 +2400,6 @@ impl GenerationScope { // // TODO: potentially simplified deserialization some day // // issue: https://github.com/dcSpark/cddl-codegen/issues/145 // } else { - deser_code.content.line( - "let initial_position = raw.as_mut_ref().stream_position().unwrap();", - ); let mut variant_final_exprs = config.final_exprs.clone(); if cli.preserve_encodings { for enc_var in encoding_fields( @@ -2409,11 +2424,16 @@ impl GenerationScope { cli, ); return_if_deserialized - .line(format!("Ok(({})) => return Ok({}),", - variant_final_exprs.join(", "), - final_expr(variant_final_exprs.clone(), Some(format!("{}::{}", ident, variant.name))))) - .line("Err(_) => raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap(),") - .after(";"); + .line(format!( + "Ok(({})) => return Ok({}),", + variant_final_exprs.join(", "), + final_expr( + variant_final_exprs.clone(), + Some(format!("{}::{}", ident, variant.name)) + ) + )) + .line("Err(_) => raw.to_string(),") + .after(";"); deser_code.content.push_block(return_if_deserialized); } deser_code.content.line(&format!( @@ -2998,7 +3018,7 @@ impl GenerationScope { }; let name_overload = "inner_de"; deser_code.content.line(&format!( - "let {} = &mut Deserializer::from(std::io::Cursor::new({}_bytes));", + "let {} = &mut Deserializer::from({}_bytes);", name_overload, config.var_name )); self.generate_deserialize( @@ -3254,7 +3274,7 @@ fn canonical_param(cli: &Cli) -> &'static str { fn encoding_var_macros(used_in_key: bool, custom_json: bool, cli: &Cli) -> String { let mut ret = if used_in_key { format!( - "#[derivative({})]\n", + "#[cfg_attr(feature = \"std\", derivative({}))]\n", key_derives(true, cli) .iter() .map(|derive| format!("{derive}=\"ignore\"")) @@ -3528,18 +3548,28 @@ impl CodeBlock for BlocksOrLines { trait DataType { fn derive(&mut self, derive: &str) -> &mut Self; + + fn cfg_attr(&mut self, cfg_attr: &str) -> &mut Self; } impl DataType for codegen::Struct { fn derive(&mut self, derive: &str) -> &mut Self { self.derive(derive) } + + fn cfg_attr(&mut self, cfg_attr: &str) -> &mut Self { + self.cfg_attr(cfg_attr) + } } impl DataType for codegen::Enum { fn derive(&mut self, derive: &str) -> &mut Self { self.derive(derive) } + + fn cfg_attr(&mut self, cfg_attr: &str) -> &mut Self { + self.cfg_attr(cfg_attr) + } } fn create_base_rust_struct( @@ -4719,7 +4749,7 @@ fn generate_array_struct_deserialization( // There's no nice way to access this as Deserializer::special_break() consumes // the byte so we'll just inline this ugly code instead if field_cbor_types.contains(&cbor_event::Type::Special) { - "if raw.as_mut_ref().fill_buf().ok().and_then(|buf| buf.get(0)).map(|byte: &u8| cbor_event::Type::from(*byte) == cbor_event::Type::Special && (*byte & 0b0001_1111) != 0x1f).unwrap_or(false)".to_owned() + "if raw.as_ref().get(0).map(|byte: &u8| cbor_event::Type::from(*byte) == cbor_event::Type::Special && (*byte & 0b0001_1111) != 0x1f).unwrap_or(false)".to_owned() } else { format!("if raw.cbor_type().map(|ty| ty == {type_str}).unwrap_or(false)") } @@ -6405,7 +6435,7 @@ fn make_enum_variant_return_if_deserialized( } _ => { let mut variant_deser = - Block::new("match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError>"); + Block::new("match (|raw: &mut Deserializer| -> Result<_, DeserializeError>"); variant_deser.after(")(raw)"); variant_deser.push_all(variant_deser_code.content); deser_body.push_block(variant_deser); @@ -6575,9 +6605,7 @@ fn generate_enum( } }; if non_overlapping_types_match.is_none() { - deser_body - .line("let initial_position = raw.as_mut_ref().stream_position().unwrap();") - .line("let mut errs = Vec::new();"); + deser_body.line("let mut errs = Vec::new();"); } for variant in variants.iter() { let enum_gen_info = EnumVariantInRust::new(types, variant, rep, cli); @@ -6996,7 +7024,7 @@ fn generate_enum( cli, ); let mut variant_deser = Block::new( - "match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError>", + "match (|raw: &mut Deserializer| -> Result<_, DeserializeError>", ); variant_deser.after(")(raw)"); variant_deser.push_all(variant_deser_code.content); @@ -7010,7 +7038,7 @@ fn generate_enum( let mut variant_deser_failed_block = Block::new("Err(e) =>"); variant_deser_failed_block .line(format!("errs.push(e.annotate(\"{}\"));", variant.name)) - .line("raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap();"); + .line("raw.to_string();"); return_if_deserialized.push_block(variant_deser_failed_block); return_if_deserialized.after(";"); deser_body.push_block(return_if_deserialized); @@ -7049,10 +7077,10 @@ fn generate_enum( fn make_serialization_function(name: &str, cli: &Cli) -> codegen::Function { let mut f = codegen::Function::new(name); - f.generic("'se, W: Write") - .ret("cbor_event::Result<&'se mut Serializer>") + f.generic("'se") + .ret("cbor_event::Result<&'se mut Serializer>") .arg_ref_self() - .arg("serializer", "&'se mut Serializer"); + .arg("serializer", "&'se mut Serializer"); if cli.preserve_encodings && cli.canonical_form { f.arg("force_canonical", "bool"); } @@ -7071,9 +7099,8 @@ fn make_serialization_impl(name: &str, cli: &Cli) -> codegen::Impl { fn make_deserialization_function(name: &str) -> codegen::Function { let mut f = codegen::Function::new(name); - f.generic("R: BufRead + Seek") - .ret("Result") - .arg("raw", "&mut Deserializer"); + f.ret("Result") + .arg("raw", "&mut Deserializer"); f } @@ -7624,6 +7651,8 @@ fn add_struct_derives( cli: &Cli, ) { data_type.derive("Clone").derive("Debug"); + let mut std_derives = vec![]; + let mut std_predicates = vec![]; if !custom_json { if cli.json_serde_derives { data_type @@ -7631,15 +7660,16 @@ fn add_struct_derives( .derive("serde::Serialize"); } if cli.json_schema_export { - data_type.derive("schemars::JsonSchema"); + std_derives.push("schemars::JsonSchema".to_string()); } } if used_in_key { if cli.preserve_encodings { // there's no way to do non-derive() proc macros in the codegen // cate so we must sadly use a newline like this. codegen manages indentation - data_type.derive(&format!( - "derivative::Derivative)]\n#[derivative({}", + std_derives.push("derivative::Derivative".to_string()); + std_predicates.push(format!( + "derivative({})", key_derives(false, cli) .iter() .map(|tr| match *tr { @@ -7657,6 +7687,12 @@ fn add_struct_derives( } } } + if !std_derives.is_empty() { + std_predicates.insert(0, format!("derive({})", std_derives.join(", "))); + } + if !std_predicates.is_empty() { + data_type.cfg_attr(&format!("feature = \"std\", {}", std_predicates.join(", "))); + } } fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes, cli: &Cli) { @@ -7695,7 +7731,7 @@ fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes, cli: .arg("string", "&str") .ret("Result") .line("// have to redefine so it's visible in WASM") - .line("std::str::FromStr::from_str(string).map(Self).map_err(|e| JsError::new(&format!(\"Int.from_str({}): {:?}\", string, e)))"); + .line("alloc::str::FromStr::from_str(string).map(Self).map_err(|e| JsError::new(&format!(\"Int.from_str({}): {:?}\", string, e)))"); wrapper .s_impl @@ -7824,16 +7860,16 @@ fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes, cli: .line("Self::Nint(x) => write!(f, \"-{}\", x + 1),"); } display - .impl_trait("std::fmt::Display") + .impl_trait("core::fmt::Display") .new_fn("fmt") .arg_ref_self() - .arg("f", "&mut std::fmt::Formatter<'_>") - .ret("std::fmt::Result") + .arg("f", "&mut core::fmt::Formatter<'_>") + .ret("core::fmt::Result") .push_block(display_match); let mut from_str = codegen::Impl::new("Int"); from_str - .impl_trait("std::str::FromStr") + .impl_trait("core::str::FromStr") .associate_type("Err", "IntError") .new_fn("from_str") .arg("s", "&str") @@ -7854,7 +7890,7 @@ fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes, cli: } try_from_i128 .impl_trait("TryFrom") - .associate_type("Error", "std::num::TryFromIntError") + .associate_type("Error", "core::num::TryFromIntError") .new_fn("try_from") .arg("x", "i128") .ret("Result") diff --git a/static/Cargo_rust.toml b/static/Cargo_rust.toml index 8a1c63e..dcbc914 100644 --- a/static/Cargo_rust.toml +++ b/static/Cargo_rust.toml @@ -3,8 +3,8 @@ name = "cddl-lib" version = "0.1.0" edition = "2018" -[lib] -crate-type = ["cdylib", "rlib"] +[features] +std = [] [dependencies] -cbor_event = "2.4.0" +cbor_event = { git = "https://github.com/primetype/cbor_event" } diff --git a/static/Cargo_wasm.toml b/static/Cargo_wasm.toml index 9bad5bb..d9993ff 100644 --- a/static/Cargo_wasm.toml +++ b/static/Cargo_wasm.toml @@ -8,6 +8,6 @@ crate-type = ["cdylib", "rlib"] [dependencies] cddl-lib = { path = "../rust" } -cbor_event = "2.4.0" -wasm-bindgen = { version = "0.2", features=["serde-serialize"] } +cbor_event = { git = "https://github.com/primetype/cbor_event" } +wasm-bindgen = { version = "0.2", features = ["serde-serialize"] } linked-hash-map = "0.5.3" diff --git a/static/error.rs b/static/error.rs index 6818af2..0817692 100644 --- a/static/error.rs +++ b/static/error.rs @@ -1,5 +1,8 @@ +use alloc::boxed::Box; +use alloc::format; +use alloc::string::String; +use alloc::vec::Vec; use cbor_event::{self, de::Deserializer}; -use std::io::{BufRead, Seek}; #[derive(Debug)] pub enum Key { @@ -8,8 +11,8 @@ pub enum Key { Float(f64), } -impl std::fmt::Display for Key { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { +impl core::fmt::Display for Key { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { Key::Str(x) => write!(f, "\"{}\"", x), Key::Uint(x) => write!(f, "{}", x), @@ -26,12 +29,12 @@ pub enum DeserializeFailure { DuplicateKey(Key), EndingBreakMissing, ExpectedNull, - FixedValueMismatch{ + FixedValueMismatch { found: Key, expected: Key, }, /// Invalid internal structure imposed on top of the CBOR format - InvalidStructure(Box), + InvalidStructure(Box), MandatoryFieldMissing(Key), NoVariantMatched, NoVariantMatchedWithCauses(Vec), @@ -40,7 +43,7 @@ pub enum DeserializeFailure { min: Option, max: Option, }, - TagMismatch{ + TagMismatch { found: u64, expected: u64, }, @@ -70,8 +73,8 @@ impl DeserializeError { } } - fn fmt_indent(&self, f: &mut std::fmt::Formatter<'_>, indent: u32) -> std::fmt::Result { - use std::fmt::Display; + fn fmt_indent(&self, f: &mut core::fmt::Formatter<'_>, indent: u32) -> core::fmt::Result { + use core::fmt::Display; for _ in 0..indent { write!(f, "\t")?; } @@ -80,7 +83,10 @@ impl DeserializeError { None => write!(f, "Deserialization: "), }?; match &self.failure { - DeserializeFailure::BreakInDefiniteLen => write!(f, "Encountered CBOR Break while reading definite length sequence"), + DeserializeFailure::BreakInDefiniteLen => write!( + f, + "Encountered CBOR Break while reading definite length sequence" + ), DeserializeFailure::CBOR(e) => e.fmt(f), DeserializeFailure::DefiniteLenMismatch(found, expected) => { write!(f, "Definite length mismatch: found {}", found)?; @@ -88,15 +94,19 @@ impl DeserializeError { write!(f, ", expected: {}", expected_elems)?; } Ok(()) - }, + } DeserializeFailure::DuplicateKey(key) => write!(f, "Duplicate key: {}", key), DeserializeFailure::EndingBreakMissing => write!(f, "Missing ending CBOR Break"), DeserializeFailure::ExpectedNull => write!(f, "Expected null, found other type"), - DeserializeFailure::FixedValueMismatch{ found, expected } => write!(f, "Expected fixed value {} found {}", expected, found), + DeserializeFailure::FixedValueMismatch { found, expected } => { + write!(f, "Expected fixed value {} found {}", expected, found) + } DeserializeFailure::InvalidStructure(e) => { write!(f, "Invalid internal structure: {}", e) } - DeserializeFailure::MandatoryFieldMissing(key) => write!(f, "Mandatory field {} not found", key), + DeserializeFailure::MandatoryFieldMissing(key) => { + write!(f, "Mandatory field {} not found", key) + } DeserializeFailure::NoVariantMatched => write!(f, "No variant matched"), DeserializeFailure::NoVariantMatchedWithCauses(errs) => { write!(f, "No variant matched. Failures:\n")?; @@ -112,17 +122,21 @@ impl DeserializeError { (None, Some(max)) => write!(f, "{} not at most {}", found, max), (None, None) => write!(f, "invalid range (no min nor max specified)"), }, - DeserializeFailure::TagMismatch{ found, expected } => write!(f, "Expected tag {}, found {}", expected, found), + DeserializeFailure::TagMismatch { found, expected } => { + write!(f, "Expected tag {}, found {}", expected, found) + } DeserializeFailure::UnknownKey(key) => write!(f, "Found unexpected key {}", key), - DeserializeFailure::UnexpectedKeyType(ty) => write!(f, "Found unexpected key of CBOR type {:?}", ty), + DeserializeFailure::UnexpectedKeyType(ty) => { + write!(f, "Found unexpected key of CBOR type {:?}", ty) + } } } } -impl std::error::Error for DeserializeError {} +impl core::error::Error for DeserializeError {} -impl std::fmt::Display for DeserializeError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { +impl core::fmt::Display for DeserializeError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { self.fmt_indent(f, 0) } } diff --git a/static/ordered_hash_map.rs b/static/ordered_hash_map.rs index d66bb43..087b914 100644 --- a/static/ordered_hash_map.rs +++ b/static/ordered_hash_map.rs @@ -1,10 +1,16 @@ +use alloc::format; +use alloc::string::String; use core::hash::Hash; #[derive(Clone, Debug, Default, Hash, Ord, Eq, PartialEq, PartialOrd)] -pub struct OrderedHashMap(linked_hash_map::LinkedHashMap) where - K : Hash + Eq + Ord; +pub struct OrderedHashMap(linked_hash_map::LinkedHashMap) +where + K: Hash + Eq + Ord; -impl std::ops::Deref for OrderedHashMap where K : Hash + Eq + Ord { +impl core::ops::Deref for OrderedHashMap +where + K: Hash + Eq + Ord, +{ type Target = linked_hash_map::LinkedHashMap; fn deref(&self) -> &Self::Target { @@ -12,15 +18,20 @@ impl std::ops::Deref for OrderedHashMap where K : Hash + Eq + Ord { } } -impl std::ops::DerefMut for OrderedHashMap where K : Hash + Eq + Ord { +impl core::ops::DerefMut for OrderedHashMap +where + K: Hash + Eq + Ord, +{ fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 } } -impl OrderedHashMap where K : Hash + Eq + Ord { +impl OrderedHashMap +where + K: Hash + Eq + Ord, +{ pub fn new() -> Self { Self(linked_hash_map::LinkedHashMap::new()) } } - diff --git a/static/ordered_hash_map_json.rs b/static/ordered_hash_map_json.rs index b519287..c2ca306 100644 --- a/static/ordered_hash_map_json.rs +++ b/static/ordered_hash_map_json.rs @@ -1,19 +1,29 @@ -impl serde::Serialize for OrderedHashMap where - K : Hash + Eq + Ord + serde::Serialize, - V: serde::Serialize { +impl serde::Serialize for OrderedHashMap +where + K: Hash + Eq + Ord + serde::Serialize, + V: serde::Serialize, +{ fn serialize(&self, serializer: S) -> Result - where S: serde::Serializer { - let map = self.iter().collect::>(); + where + S: serde::Serializer, + { + let map = self.iter().collect::>(); map.serialize(serializer) } } -impl<'de, K, V> serde::de::Deserialize<'de> for OrderedHashMap where +impl<'de, K, V> serde::de::Deserialize<'de> for OrderedHashMap +where K: Hash + Eq + Ord + serde::Deserialize<'de>, - V: serde::Deserialize<'de> { - fn deserialize(deserializer: D) -> Result where - D: serde::de::Deserializer<'de> { - let map = as serde::de::Deserialize>::deserialize(deserializer)?; + V: serde::Deserialize<'de>, +{ + fn deserialize(deserializer: D) -> Result + where + D: serde::de::Deserializer<'de>, + { + let map = as serde::de::Deserialize>::deserialize( + deserializer, + )?; Ok(Self(map.into_iter().collect())) } } diff --git a/static/ordered_hash_map_schemars.rs b/static/ordered_hash_map_schemars.rs index d315bbe..74ee0de 100644 --- a/static/ordered_hash_map_schemars.rs +++ b/static/ordered_hash_map_schemars.rs @@ -1,10 +1,15 @@ -impl schemars::JsonSchema for OrderedHashMap where +impl schemars::JsonSchema for OrderedHashMap +where K: Hash + Eq + Ord + schemars::JsonSchema, - V: schemars::JsonSchema { - fn schema_name() -> String { format!("OrderedHashMap<{}, {}>", K::schema_name(), V::schema_name()) } + V: schemars::JsonSchema, +{ + fn schema_name() -> String { + format!("OrderedHashMap<{}, {}>", K::schema_name(), V::schema_name()) + } fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema { - std::collections::BTreeMap::::json_schema(gen) + alloc::collections::BTreeMap::::json_schema(gen) + } + fn is_referenceable() -> bool { + alloc::collections::BTreeMap::::is_referenceable() } - fn is_referenceable() -> bool { std::collections::BTreeMap::::is_referenceable() } } - diff --git a/static/serialization.rs b/static/serialization.rs index 7c191d3..c1a0c9a 100644 --- a/static/serialization.rs +++ b/static/serialization.rs @@ -1,17 +1,20 @@ // same as cbor_event::de::Deserialize but with our DeserializeError pub trait Deserialize { - fn from_cbor_bytes(data: &[u8]) -> Result where Self: Sized { - let mut raw = Deserializer::from(std::io::Cursor::new(data)); + fn from_cbor_bytes(data: &[u8]) -> Result + where + Self: Sized, + { + let mut raw = Deserializer::from(Vec::from(data)); Self::deserialize(&mut raw) } - fn deserialize( - raw: &mut Deserializer, - ) -> Result where Self: Sized; + fn deserialize(raw: &mut Deserializer) -> Result + where + Self: Sized; } impl Deserialize for T { - fn deserialize(raw: &mut Deserializer) -> Result { + fn deserialize(raw: &mut Deserializer) -> Result { T::deserialize(raw).map_err(DeserializeError::from) } } diff --git a/static/serialization_non_force_canonical.rs b/static/serialization_non_force_canonical.rs index ac8e899..918f044 100644 --- a/static/serialization_non_force_canonical.rs +++ b/static/serialization_non_force_canonical.rs @@ -1,8 +1,8 @@ pub trait SerializeEmbeddedGroup { - fn serialize_as_embedded_group<'a, W: Write + Sized>( + fn serialize_as_embedded_group<'a>( &self, - serializer: &'a mut Serializer, - ) -> cbor_event::Result<&'a mut Serializer>; + serializer: &'a mut Serializer, + ) -> cbor_event::Result<&'a mut Serializer>; } pub trait ToCBORBytes { diff --git a/static/serialization_non_preserve.rs b/static/serialization_non_preserve.rs index 064725d..3a466d8 100644 --- a/static/serialization_non_preserve.rs +++ b/static/serialization_non_preserve.rs @@ -26,7 +26,7 @@ impl CBORReadLen { } else { Ok(()) } - }, + } cbor_event::Len::Indefinite => Ok(()), } } @@ -39,16 +39,18 @@ impl CBORReadLen { } else { Err(DeserializeFailure::DefiniteLenMismatch(n, Some(self.read))) } - }, + } cbor_event::Len::Indefinite => Ok(()), } } } pub trait DeserializeEmbeddedGroup { - fn deserialize_as_embedded_group( - raw: &mut Deserializer, + fn deserialize_as_embedded_group( + raw: &mut Deserializer, read_len: &mut CBORReadLen, len: cbor_event::Len, - ) -> Result where Self: Sized; + ) -> Result + where + Self: Sized; } diff --git a/static/serialization_preserve.rs b/static/serialization_preserve.rs index 0e18d4a..886d9e6 100644 --- a/static/serialization_preserve.rs +++ b/static/serialization_preserve.rs @@ -26,7 +26,7 @@ impl CBORReadLen { } else { Ok(()) } - }, + } cbor_event::LenSz::Indefinite => Ok(()), } } @@ -39,18 +39,20 @@ impl CBORReadLen { } else { Err(DeserializeFailure::DefiniteLenMismatch(n, Some(self.read))) } - }, + } cbor_event::LenSz::Indefinite => Ok(()), } } } pub trait DeserializeEmbeddedGroup { - fn deserialize_as_embedded_group( - raw: &mut Deserializer, + fn deserialize_as_embedded_group( + raw: &mut Deserializer, read_len: &mut CBORReadLen, len: cbor_event::LenSz, - ) -> Result where Self: Sized; + ) -> Result + where + Self: Sized; } #[inline] @@ -80,11 +82,13 @@ impl Default for LenEncoding { impl From for LenEncoding { fn from(len_sz: cbor_event::LenSz) -> Self { match len_sz { - cbor_event::LenSz::Len(len, sz) => if cbor_event::Sz::canonical(len) == sz { - Self::Canonical - } else { - Self::Definite(sz) - }, + cbor_event::LenSz::Len(len, sz) => { + if cbor_event::Sz::canonical(len) == sz { + Self::Canonical + } else { + Self::Definite(sz) + } + } cbor_event::LenSz::Indefinite => Self::Indefinite, } } diff --git a/static/serialization_preserve_force_canonical.rs b/static/serialization_preserve_force_canonical.rs index 465c9c0..2649bd9 100644 --- a/static/serialization_preserve_force_canonical.rs +++ b/static/serialization_preserve_force_canonical.rs @@ -1,11 +1,17 @@ #[inline] -pub(crate) fn fit_sz(len: u64, sz: Option, force_canonical: bool) -> cbor_event::Sz { +pub(crate) fn fit_sz( + len: u64, + sz: Option, + force_canonical: bool, +) -> cbor_event::Sz { match sz { - Some(sz) => if !force_canonical && len <= sz_max(sz) { - sz - } else { - cbor_event::Sz::canonical(len) - }, + Some(sz) => { + if !force_canonical && len <= sz_max(sz) { + sz + } else { + cbor_event::Sz::canonical(len) + } + } None => cbor_event::Sz::canonical(len), } } @@ -17,17 +23,23 @@ impl LenEncoding { } else { match self { Self::Canonical => cbor_event::LenSz::Len(len, cbor_event::Sz::canonical(len)), - Self::Definite(sz) => if sz_max(*sz) >= len { - cbor_event::LenSz::Len(len, *sz) - } else { - cbor_event::LenSz::Len(len, cbor_event::Sz::canonical(len)) - }, + Self::Definite(sz) => { + if sz_max(*sz) >= len { + cbor_event::LenSz::Len(len, *sz) + } else { + cbor_event::LenSz::Len(len, cbor_event::Sz::canonical(len)) + } + } Self::Indefinite => cbor_event::LenSz::Indefinite, } } } - pub fn end<'a, W: Write + Sized>(&self, serializer: &'a mut Serializer, force_canonical: bool) -> cbor_event::Result<&'a mut Serializer> { + pub fn end<'a>( + &self, + serializer: &'a mut Serializer, + force_canonical: bool, + ) -> cbor_event::Result<&'a mut Serializer> { if !force_canonical && *self == Self::Indefinite { serializer.write_special(cbor_event::Special::Break)?; } @@ -42,11 +54,13 @@ impl StringEncoding { } else { match self { Self::Canonical => cbor_event::StringLenSz::Len(cbor_event::Sz::canonical(len)), - Self::Definite(sz) => if sz_max(*sz) >= len { - cbor_event::StringLenSz::Len(*sz) - } else { - cbor_event::StringLenSz::Len(cbor_event::Sz::canonical(len)) - }, + Self::Definite(sz) => { + if sz_max(*sz) >= len { + cbor_event::StringLenSz::Len(*sz) + } else { + cbor_event::StringLenSz::Len(cbor_event::Sz::canonical(len)) + } + } Self::Indefinite(lens) => cbor_event::StringLenSz::Indefinite(lens.clone()), } } @@ -66,17 +80,17 @@ pub trait Serialize { buf.finalize() } - fn serialize<'a, W: Write + Sized>( + fn serialize<'a>( &self, - serializer: &'a mut Serializer, + serializer: &'a mut Serializer, force_canonical: bool, - ) -> cbor_event::Result<&'a mut Serializer>; + ) -> cbor_event::Result<&'a mut Serializer>; } pub trait SerializeEmbeddedGroup { - fn serialize_as_embedded_group<'a, W: Write + Sized>( + fn serialize_as_embedded_group<'a>( &self, - serializer: &'a mut Serializer, + serializer: &'a mut Serializer, force_canonical: bool, - ) -> cbor_event::Result<&'a mut Serializer>; + ) -> cbor_event::Result<&'a mut Serializer>; } diff --git a/static/serialization_preserve_non_force_canonical.rs b/static/serialization_preserve_non_force_canonical.rs index d9a1bb2..370645b 100644 --- a/static/serialization_preserve_non_force_canonical.rs +++ b/static/serialization_preserve_non_force_canonical.rs @@ -1,11 +1,13 @@ #[inline] pub(crate) fn fit_sz(len: u64, sz: Option) -> cbor_event::Sz { match sz { - Some(sz) => if len <= sz_max(sz) { - sz - } else { - cbor_event::Sz::canonical(len) - }, + Some(sz) => { + if len <= sz_max(sz) { + sz + } else { + cbor_event::Sz::canonical(len) + } + } None => cbor_event::Sz::canonical(len), } } @@ -14,16 +16,21 @@ impl LenEncoding { pub fn to_len_sz(&self, len: u64) -> cbor_event::LenSz { match self { Self::Canonical => cbor_event::LenSz::Len(len, cbor_event::Sz::canonical(len)), - Self::Definite(sz) => if sz_max(*sz) >= len { - cbor_event::LenSz::Len(len, *sz) - } else { - cbor_event::LenSz::Len(len, cbor_event::Sz::canonical(len)) - }, + Self::Definite(sz) => { + if sz_max(*sz) >= len { + cbor_event::LenSz::Len(len, *sz) + } else { + cbor_event::LenSz::Len(len, cbor_event::Sz::canonical(len)) + } + } Self::Indefinite => cbor_event::LenSz::Indefinite, } } - pub fn end<'a, W: Write + Sized>(&self, serializer: &'a mut Serializer) -> cbor_event::Result<&'a mut Serializer> { + pub fn end<'a>( + &self, + serializer: &'a mut Serializer, + ) -> cbor_event::Result<&'a mut Serializer> { if *self == Self::Indefinite { serializer.write_special(cbor_event::Special::Break)?; } @@ -35,11 +42,13 @@ impl StringEncoding { pub fn to_str_len_sz(&self, len: u64) -> cbor_event::StringLenSz { match self { Self::Canonical => cbor_event::StringLenSz::Len(cbor_event::Sz::canonical(len)), - Self::Definite(sz) => if sz_max(*sz) >= len { - cbor_event::StringLenSz::Len(*sz) - } else { - cbor_event::StringLenSz::Len(cbor_event::Sz::canonical(len)) - }, + Self::Definite(sz) => { + if sz_max(*sz) >= len { + cbor_event::StringLenSz::Len(*sz) + } else { + cbor_event::StringLenSz::Len(cbor_event::Sz::canonical(len)) + } + } Self::Indefinite(lens) => cbor_event::StringLenSz::Indefinite(lens.clone()), } } diff --git a/tests/canonical/tests.rs b/tests/canonical/tests.rs index 26c9575..75dafd8 100644 --- a/tests/canonical/tests.rs +++ b/tests/canonical/tests.rs @@ -1,42 +1,146 @@ #[cfg(test)] mod tests { use super::*; - use cbor_event::{de::Deserializer, Sz, StringLenSz}; + use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; + use std::{format, print, println}; + + fn print_cbor_types(obj_name: &str, vec: Vec) { + use cbor_event::Type; + let mut raw = cbor_event::de::Deserializer::from(vec); + let mut lens = Vec::new(); + let consume_elem = |lens: &mut Vec| { + if let Some(len) = lens.last_mut() { + if let cbor_event::LenSz::Len(n, _) = len { + *n -= 1; + } + } + }; + let reduce_depth = |lens: &mut Vec| { + while let Some(cbor_event::LenSz::Len(0, _)) = lens.last() { + lens.pop(); + println!("{}}}", "\t".repeat(lens.len())); + } + }; + println!("{} = {{", obj_name); + loop { + print!("{}", "\t".repeat(lens.len())); + match raw.cbor_type() { + Err(_) => break, + Ok(Type::UnsignedInteger) => { + let (x, sz) = raw.unsigned_integer_sz().unwrap(); + println!("UINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::NegativeInteger) => { + let (x, sz) = raw.negative_integer_sz().unwrap(); + println!("NINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Bytes) => { + let (x, sz) = raw.bytes_sz().unwrap(); + println!("BYTES({:?}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Text) => { + let (x, sz) = raw.text_sz().unwrap(); + println!("TEXT(\"{}\", {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Array) => { + let len = raw.array_sz().unwrap(); + println!("ARRAY({:?}) {{", len); + consume_elem(&mut lens); + lens.push(len); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Map) => { + let len = raw.map_sz().unwrap(); + println!("MAP({:?}) {{", len); + consume_elem(&mut lens); + lens.push(match len { + cbor_event::LenSz::Len(n, sz) => cbor_event::LenSz::Len(2 * n, sz), + cbor_event::LenSz::Indefinite => cbor_event::LenSz::Indefinite, + }); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Tag) => { + let (tag, sz) = raw.tag_sz().unwrap(); + println!("TAG({}, {:?})", tag, sz); + } + Ok(Type::Special) => { + let special = raw.special().unwrap(); + println!("SPECIAL({:?})", special); + if special == cbor_event::Special::Break { + if let Some(cbor_event::LenSz::Indefinite) = lens.last() { + lens.pop(); + reduce_depth(&mut lens); + } else { + panic!("unexpected break"); + } + } else { + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + } + } + } + println!("}}"); + } fn deser_test_orig(orig: &T) { - print_cbor_types("orig (original enc)", &orig.to_cbor_bytes()); - let deser = T::deserialize(&mut Deserializer::from(std::io::Cursor::new(orig.to_cbor_bytes()))).unwrap(); - print_cbor_types("deser", &deser.to_cbor_bytes()); + print_cbor_types("orig (original enc)", orig.to_cbor_bytes()); + let deser = T::deserialize(&mut Deserializer::from(orig.to_cbor_bytes())).unwrap(); + print_cbor_types("deser", deser.to_cbor_bytes()); assert_eq!(orig.to_cbor_bytes(), deser.to_cbor_bytes()); } fn deser_test_canonical(orig: &T) { - print_cbor_types("orig (canonical)", &orig.to_canonical_cbor_bytes()); - let deser = T::deserialize(&mut Deserializer::from(std::io::Cursor::new(orig.to_canonical_cbor_bytes()))).unwrap(); - print_cbor_types("deser", &deser.to_canonical_cbor_bytes()); - assert_eq!(orig.to_canonical_cbor_bytes(), deser.to_canonical_cbor_bytes()); + print_cbor_types("orig (canonical)", orig.to_canonical_cbor_bytes()); + let deser = + T::deserialize(&mut Deserializer::from(orig.to_canonical_cbor_bytes())).unwrap(); + print_cbor_types("deser", deser.to_canonical_cbor_bytes()); + assert_eq!( + orig.to_canonical_cbor_bytes(), + deser.to_canonical_cbor_bytes() + ); } #[test] fn struct_array() { let non_canonical_bytes = vec![ cbor_tag_sz(11, Sz::Eight), - vec![ARR_INDEF], - vec![0x09], - cbor_string("jdskfjdsfkjad"), - vec![0x42, 0xB4, 0xD3], - vec![BREAK] - ].into_iter().flatten().clone().collect::>(); + vec![ARR_INDEF], + vec![0x09], + cbor_string("jdskfjdsfkjad"), + vec![0x42, 0xB4, 0xD3], + vec![BREAK], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let foo = Foo::from_cbor_bytes(&non_canonical_bytes).unwrap(); assert_eq!(foo.to_cbor_bytes(), non_canonical_bytes); let canonical_bytes = vec![ cbor_tag(11), - arr_def(3), - vec![0x09], - cbor_string("jdskfjdsfkjad"), - vec![0x42, 0xB4, 0xD3], - ].into_iter().flatten().clone().collect::>(); + arr_def(3), + vec![0x09], + cbor_string("jdskfjdsfkjad"), + vec![0x42, 0xB4, 0xD3], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); assert_eq!(foo.to_canonical_cbor_bytes(), canonical_bytes); deser_test_canonical(&foo); deser_test_orig(&foo); @@ -47,40 +151,48 @@ mod tests { // tests for indefinite inside both map/array structs (original test) let non_canonical_bytes = vec![ vec![MAP_INDEF], - cbor_string("foo"), - cbor_tag_sz(13, Sz::One), - cbor_tag_sz(11, Sz::Two), - vec![ARR_INDEF], - vec![0x09], - cbor_string("jdskfjdsfkjad"), - vec![0x42, 0xB4, 0xD3], - vec![BREAK], - vec![0x01u8], - vec![0x15], - cbor_string("derp"), - vec![0x013u8], - cbor_string("five"), - vec![0x05u8], - vec![BREAK] - ].into_iter().flatten().clone().collect::>(); + cbor_string("foo"), + cbor_tag_sz(13, Sz::One), + cbor_tag_sz(11, Sz::Two), + vec![ARR_INDEF], + vec![0x09], + cbor_string("jdskfjdsfkjad"), + vec![0x42, 0xB4, 0xD3], + vec![BREAK], + vec![0x01u8], + vec![0x15], + cbor_string("derp"), + vec![0x013u8], + cbor_string("five"), + vec![0x05u8], + vec![BREAK], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let bar = Bar::from_cbor_bytes(&non_canonical_bytes).unwrap(); assert_eq!(bar.to_cbor_bytes(), non_canonical_bytes); let canonical_bytes = vec![ map_def(4), - vec![0x01u8], - vec![0x15], - cbor_string("foo"), - cbor_tag(13), - cbor_tag(11), - arr_def(3), - vec![0x09], - cbor_string("jdskfjdsfkjad"), - vec![0x42, 0xB4, 0xD3], - cbor_string("derp"), - vec![0x013u8], - cbor_string("five"), - vec![0x05u8], - ].into_iter().flatten().clone().collect::>(); + vec![0x01u8], + vec![0x15], + cbor_string("foo"), + cbor_tag(13), + cbor_tag(11), + arr_def(3), + vec![0x09], + cbor_string("jdskfjdsfkjad"), + vec![0x42, 0xB4, 0xD3], + cbor_string("derp"), + vec![0x013u8], + cbor_string("five"), + vec![0x05u8], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); assert_eq!(bar.to_canonical_cbor_bytes(), canonical_bytes); deser_test_canonical(&bar); deser_test_orig(&bar); @@ -88,36 +200,52 @@ mod tests { // tests for all other possible encodings (new tests after complete encoding preservation) let canonical_bytes_all = vec![ map_def(5), - vec![0x01u8], - vec![NULL], - vec![0x05], - cbor_string("XYZ"), - cbor_string("foo"), - cbor_tag(13), - cbor_tag(11), - arr_def(3), - vec![0x09], - cbor_string("abcd"), - vec![0x44, 0xB4, 0xD3, 0x09, 0x00], - cbor_string("derp"), - vec![0x013u8], - cbor_string("five"), - vec![0x05u8], - ].into_iter().flatten().clone().collect::>(); + vec![0x01u8], + vec![NULL], + vec![0x05], + cbor_string("XYZ"), + cbor_string("foo"), + cbor_tag(13), + cbor_tag(11), + arr_def(3), + vec![0x09], + cbor_string("abcd"), + vec![0x44, 0xB4, 0xD3, 0x09, 0x00], + cbor_string("derp"), + vec![0x013u8], + cbor_string("five"), + vec![0x05u8], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let str_3_encodings = vec![ StringLenSz::Len(Sz::Inline), StringLenSz::Len(Sz::Eight), - StringLenSz::Indefinite(vec![(0, Sz::Inline), (2, Sz::One), (1, Sz::Four), (0, Sz::Eight)]) + StringLenSz::Indefinite(vec![ + (0, Sz::Inline), + (2, Sz::One), + (1, Sz::Four), + (0, Sz::Eight), + ]), ]; let str_4_encodings = vec![ StringLenSz::Indefinite(vec![(4, Sz::Inline)]), StringLenSz::Len(Sz::Two), - StringLenSz::Indefinite(vec![(1, Sz::Inline), (1, Sz::Four), (1, Sz::One), (1, Sz::Two)]), + StringLenSz::Indefinite(vec![ + (1, Sz::Inline), + (1, Sz::Four), + (1, Sz::One), + (1, Sz::Two), + ]), ]; let def_encodings = vec![Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for def_enc in def_encodings { for (str_3, str_4) in str_3_encodings.iter().zip(str_4_encodings.iter()) { - for (has_5, has_derp) in [(false, false), (false, true), (true, false), (true, true)] { + for (has_5, has_derp) in + [(false, false), (false, true), (true, false), (true, true)] + { let len = if has_5 && has_derp { 5 } else if has_5 || has_derp { @@ -135,50 +263,73 @@ mod tests { let keys = [ [ cbor_str_sz("foo", str_3.clone()), - cbor_tag_sz(13, def_enc), - cbor_tag_sz(11, def_enc), - arr_sz(3, def_enc), - cbor_int(9, def_enc), - cbor_str_sz("abcd", str_4.clone()), - cbor_bytes_sz(vec![0xB4, 0xD3, 0x09, 0x00], str_4.clone()), - ].into_iter().flatten().copied().collect::>(), + cbor_tag_sz(13, def_enc), + cbor_tag_sz(11, def_enc), + arr_sz(3, def_enc), + cbor_int(9, def_enc), + cbor_str_sz("abcd", str_4.clone()), + cbor_bytes_sz(vec![0xB4, 0xD3, 0x09, 0x00], str_4.clone()), + ] + .into_iter() + .flatten() + .copied() + .collect::>(), if has_5 { - [ - cbor_int(5, def_enc), - cbor_str_sz("XYZ", str_3.clone()), - ].into_iter().flatten().copied().collect::>() + [cbor_int(5, def_enc), cbor_str_sz("XYZ", str_3.clone())] + .into_iter() + .flatten() + .copied() + .collect::>() } else { vec![] }, - [ - cbor_int(1, def_enc), - vec![NULL], - ].into_iter().flatten().copied().collect::>(), + [cbor_int(1, def_enc), vec![NULL]] + .into_iter() + .flatten() + .copied() + .collect::>(), if has_derp { - [ - cbor_str_sz("derp", str_4.clone()), - cbor_int(19, def_enc), - ].into_iter().flatten().copied().collect::>() + [cbor_str_sz("derp", str_4.clone()), cbor_int(19, def_enc)] + .into_iter() + .flatten() + .copied() + .collect::>() } else { vec![] }, - [ - cbor_str_sz("five", str_4.clone()), - cbor_int(5, def_enc), - ].into_iter().flatten().copied().collect::>(), + [cbor_str_sz("five", str_4.clone()), cbor_int(5, def_enc)] + .into_iter() + .flatten() + .copied() + .collect::>(), ]; // just a subset of permutations to not take forever - for key_order in [[0, 1, 2, 3, 4], [4, 3, 2, 1, 0], [3, 1, 0, 4, 2], [0, 2, 4, 1, 3], [2, 0, 3, 4, 1]] { + for key_order in [ + [0, 1, 2, 3, 4], + [4, 3, 2, 1, 0], + [3, 1, 0, 4, 2], + [0, 2, 4, 1, 3], + [2, 0, 3, 4, 1], + ] { let mut irregular_encoding = map_sz(len, def_enc); for i in 0..5 { irregular_encoding.extend_from_slice(&keys[key_order[i]]); } - print_cbor_types("irregular_encoding", &irregular_encoding); + print_cbor_types("irregular_encoding", irregular_encoding.clone()); let irregular_bar = Bar::from_cbor_bytes(&irregular_encoding).unwrap(); - print_cbor_types("irregular_bar.to_cbor_bytes()", &irregular_bar.to_cbor_bytes()); + print_cbor_types( + "irregular_bar.to_cbor_bytes()", + irregular_bar.to_cbor_bytes(), + ); assert_eq!(irregular_bar.to_cbor_bytes(), irregular_encoding); - print_cbor_types("irregular_bar.to_canonical_cbor_bytes()", &irregular_bar.to_canonical_cbor_bytes()); - assert_eq!(irregular_bar.to_canonical_cbor_bytes(), canonical_bar.to_cbor_bytes()); + print_cbor_types( + "irregular_bar.to_canonical_cbor_bytes()", + irregular_bar.to_canonical_cbor_bytes(), + ); + assert_eq!( + irregular_bar.to_canonical_cbor_bytes(), + canonical_bar.to_cbor_bytes() + ); } } } @@ -189,56 +340,73 @@ mod tests { fn table_arr_members() { let non_canonical_bytes = vec![ vec![MAP_INDEF], - cbor_str_sz("arr2", StringLenSz::Indefinite(vec![(2, Sz::Inline), (0, Sz::Inline), (2, Sz::Four)])), - vec![ARR_INDEF], - cbor_tag_sz(11, Sz::Four), - vec![ARR_INDEF], - cbor_int(0, Sz::Eight), - cbor_str_sz("Zero", StringLenSz::Len(Sz::Four)), - cbor_bytes_sz(vec![], StringLenSz::Indefinite(vec![(0, Sz::Inline), (0, Sz::Four)])), - vec![BREAK], - vec![BREAK], - cbor_str_sz("table", StringLenSz::Len(Sz::One)), - map_sz(3, Sz::Four), - cbor_int(16, Sz::Eight), - cbor_str_sz("Sixteen", StringLenSz::Indefinite(vec![(3, Sz::Inline), (4, Sz::Four)])), - cbor_int(4, Sz::Two), - cbor_str_sz("Four", StringLenSz::Len(Sz::Two)), - cbor_int(8, Sz::Four), - cbor_str_sz("Eight", StringLenSz::Len(Sz::Inline)), - cbor_str_sz("arr", StringLenSz::Indefinite(vec![(3, Sz::Four)])), - vec![ARR_INDEF], - cbor_int(1, Sz::Eight), - cbor_int(3, Sz::Inline), - cbor_int(6, Sz::Four), - vec![BREAK], + cbor_str_sz( + "arr2", + StringLenSz::Indefinite(vec![(2, Sz::Inline), (0, Sz::Inline), (2, Sz::Four)]), + ), + vec![ARR_INDEF], + cbor_tag_sz(11, Sz::Four), + vec![ARR_INDEF], + cbor_int(0, Sz::Eight), + cbor_str_sz("Zero", StringLenSz::Len(Sz::Four)), + cbor_bytes_sz( + vec![], + StringLenSz::Indefinite(vec![(0, Sz::Inline), (0, Sz::Four)]), + ), + vec![BREAK], + vec![BREAK], + cbor_str_sz("table", StringLenSz::Len(Sz::One)), + map_sz(3, Sz::Four), + cbor_int(16, Sz::Eight), + cbor_str_sz( + "Sixteen", + StringLenSz::Indefinite(vec![(3, Sz::Inline), (4, Sz::Four)]), + ), + cbor_int(4, Sz::Two), + cbor_str_sz("Four", StringLenSz::Len(Sz::Two)), + cbor_int(8, Sz::Four), + cbor_str_sz("Eight", StringLenSz::Len(Sz::Inline)), + cbor_str_sz("arr", StringLenSz::Indefinite(vec![(3, Sz::Four)])), + vec![ARR_INDEF], + cbor_int(1, Sz::Eight), + cbor_int(3, Sz::Inline), + cbor_int(6, Sz::Four), vec![BREAK], - ].into_iter().flatten().clone().collect::>(); - print_cbor_types("non_canonical_bytes", &non_canonical_bytes); + vec![BREAK], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); + print_cbor_types("non_canonical_bytes", non_canonical_bytes.clone()); let table = TableArrMembers::from_cbor_bytes(&non_canonical_bytes).unwrap(); assert_eq!(table.to_cbor_bytes(), non_canonical_bytes); let canonical_bytes = vec![ map_def(3), - cbor_string("arr"), - arr_def(3), - vec![0x01, 0x03, 0x06], - cbor_string("arr2"), - arr_def(1), - cbor_tag(11), - arr_def(3), - vec![0x00], - cbor_string("Zero"), - vec![0x40], - cbor_string("table"), - map_def(3), - vec![0x04], - cbor_string("Four"), - vec![0x08], - cbor_string("Eight"), - vec![16u8], - cbor_string("Sixteen"), - ].into_iter().flatten().clone().collect::>(); - print_cbor_types("canonical_bytes", &canonical_bytes); + cbor_string("arr"), + arr_def(3), + vec![0x01, 0x03, 0x06], + cbor_string("arr2"), + arr_def(1), + cbor_tag(11), + arr_def(3), + vec![0x00], + cbor_string("Zero"), + vec![0x40], + cbor_string("table"), + map_def(3), + vec![0x04], + cbor_string("Four"), + vec![0x08], + cbor_string("Eight"), + vec![16u8], + cbor_string("Sixteen"), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); + print_cbor_types("canonical_bytes", canonical_bytes.clone()); assert_eq!(table.to_canonical_cbor_bytes(), canonical_bytes); deser_test_canonical(&table); deser_test_orig(&table); @@ -248,86 +416,99 @@ mod tests { fn deeply_nested() { let canonical_bytes = vec![ arr_def(1), - map_def(2), - cbor_tag(14), - cbor_bytes_sz(vec![0xAA, 0xBB, 0xCC], StringLenSz::Len(Sz::Inline)), - map_def(2), - cbor_int(3, Sz::Inline), - map_def(1), - cbor_tag(9), - cbor_int(2, Sz::Inline), - arr_def(1), - cbor_tag(18), - arr_def(1), - cbor_string("cbor"), - cbor_int(5, Sz::Inline), - map_def(0), - cbor_tag(14), - cbor_bytes_sz(vec![0xBA, 0xAD, 0xF0, 0x0D], StringLenSz::Len(Sz::Inline)), - map_def(1), - cbor_int(10, Sz::Inline), - map_def(1), - cbor_tag(9), - cbor_int(0, Sz::Inline), - arr_def(2), - cbor_tag(18), - arr_def(0), - cbor_tag(18), - arr_def(3), - cbor_string("test"), - cbor_string("XYZ"), - cbor_string("ABC"), - ].into_iter().flatten().clone().collect::>(); + map_def(2), + cbor_tag(14), + cbor_bytes_sz(vec![0xAA, 0xBB, 0xCC], StringLenSz::Len(Sz::Inline)), + map_def(2), + cbor_int(3, Sz::Inline), + map_def(1), + cbor_tag(9), + cbor_int(2, Sz::Inline), + arr_def(1), + cbor_tag(18), + arr_def(1), + cbor_string("cbor"), + cbor_int(5, Sz::Inline), + map_def(0), + cbor_tag(14), + cbor_bytes_sz(vec![0xBA, 0xAD, 0xF0, 0x0D], StringLenSz::Len(Sz::Inline)), + map_def(1), + cbor_int(10, Sz::Inline), + map_def(1), + cbor_tag(9), + cbor_int(0, Sz::Inline), + arr_def(2), + cbor_tag(18), + arr_def(0), + cbor_tag(18), + arr_def(3), + cbor_string("test"), + cbor_string("XYZ"), + cbor_string("ABC"), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let str_3_encodings = vec![ StringLenSz::Len(Sz::Inline), StringLenSz::Len(Sz::Eight), - StringLenSz::Indefinite(vec![(1, Sz::Two), (2, Sz::Four)]) + StringLenSz::Indefinite(vec![(1, Sz::Two), (2, Sz::Four)]), ]; let str_4_encodings = vec![ StringLenSz::Indefinite(vec![(4, Sz::Inline)]), StringLenSz::Len(Sz::Two), - StringLenSz::Indefinite(vec![(1, Sz::Eight), (1, Sz::Inline), (1, Sz::Inline), (1, Sz::Two)]), + StringLenSz::Indefinite(vec![ + (1, Sz::Eight), + (1, Sz::Inline), + (1, Sz::Inline), + (1, Sz::Two), + ]), ]; let def_encodings = vec![Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for def_enc in def_encodings { for (str_3, str_4) in str_3_encodings.iter().zip(str_4_encodings.iter()) { let irregular_bytes = vec![ arr_sz(1, def_enc), - vec![MAP_INDEF], - cbor_tag_sz(14, def_enc), - cbor_bytes_sz(vec![0xBA, 0xAD, 0xF0, 0x0D], str_4.clone()), - map_sz(1, def_enc), - cbor_int(10, def_enc), - map_sz(1, def_enc), - cbor_tag_sz(9, def_enc), - cbor_int(0, def_enc), - arr_sz(2, def_enc), - cbor_tag_sz(18, def_enc), - arr_sz(0, def_enc), - cbor_tag_sz(18, def_enc), - vec![ARR_INDEF], - cbor_str_sz("test", str_4.clone()), - cbor_str_sz("XYZ", str_3.clone()), - cbor_str_sz("ABC", str_3.clone()), - vec![BREAK], - cbor_tag_sz(14, def_enc), - cbor_bytes_sz(vec![0xAA, 0xBB, 0xCC], str_3.clone()), - vec![MAP_INDEF], - cbor_int(5, def_enc), - vec![MAP_INDEF], - vec![BREAK], - cbor_int(3, def_enc), - map_sz(1, def_enc), - cbor_tag_sz(9, def_enc), - cbor_int(2, def_enc), - vec![ARR_INDEF], - cbor_tag_sz(18, def_enc), - arr_sz(1, def_enc), - cbor_str_sz("cbor", str_4.clone()), - vec![BREAK], - vec![BREAK], - vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + vec![MAP_INDEF], + cbor_tag_sz(14, def_enc), + cbor_bytes_sz(vec![0xBA, 0xAD, 0xF0, 0x0D], str_4.clone()), + map_sz(1, def_enc), + cbor_int(10, def_enc), + map_sz(1, def_enc), + cbor_tag_sz(9, def_enc), + cbor_int(0, def_enc), + arr_sz(2, def_enc), + cbor_tag_sz(18, def_enc), + arr_sz(0, def_enc), + cbor_tag_sz(18, def_enc), + vec![ARR_INDEF], + cbor_str_sz("test", str_4.clone()), + cbor_str_sz("XYZ", str_3.clone()), + cbor_str_sz("ABC", str_3.clone()), + vec![BREAK], + cbor_tag_sz(14, def_enc), + cbor_bytes_sz(vec![0xAA, 0xBB, 0xCC], str_3.clone()), + vec![MAP_INDEF], + cbor_int(5, def_enc), + vec![MAP_INDEF], + vec![BREAK], + cbor_int(3, def_enc), + map_sz(1, def_enc), + cbor_tag_sz(9, def_enc), + cbor_int(2, def_enc), + vec![ARR_INDEF], + cbor_tag_sz(18, def_enc), + arr_sz(1, def_enc), + cbor_str_sz("cbor", str_4.clone()), + vec![BREAK], + vec![BREAK], + vec![BREAK], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular = DeeplyNested::from_cbor_bytes(&irregular_bytes).unwrap(); assert_eq!(irregular_bytes, irregular.to_cbor_bytes()); assert_eq!(canonical_bytes, irregular.to_canonical_cbor_bytes()); @@ -356,31 +537,59 @@ mod tests { let canonical_bytes_text = cbor_string("abcdefghijk"); let irregular_bytes_tagged_arr = vec![ cbor_tag_sz(16, *def_enc), - arr_sz(2, *def_enc), - cbor_int(1, *def_enc), - cbor_int(3, *def_enc), - ].into_iter().flatten().clone().collect::>(); + arr_sz(2, *def_enc), + cbor_int(1, *def_enc), + cbor_int(3, *def_enc), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let canonical_bytes_tagged_arr = vec![ cbor_tag(16), - arr_def(2), - cbor_int(1, Sz::Inline), - cbor_int(3, Sz::Inline), - ].into_iter().flatten().clone().collect::>(); + arr_def(2), + cbor_int(1, Sz::Inline), + cbor_int(3, Sz::Inline), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_0 = TypeChoice::from_cbor_bytes(&irregular_bytes_0).unwrap(); assert_eq!(irregular_bytes_0, irregular_0.to_cbor_bytes()); assert_eq!(canonical_bytes_0, irregular_0.to_canonical_cbor_bytes()); - let irregular_hello_world = TypeChoice::from_cbor_bytes(&irregular_bytes_hello_world).unwrap(); - assert_eq!(irregular_bytes_hello_world, irregular_hello_world.to_cbor_bytes()); - assert_eq!(canonical_bytes_hello_world, irregular_hello_world.to_canonical_cbor_bytes()); + let irregular_hello_world = + TypeChoice::from_cbor_bytes(&irregular_bytes_hello_world).unwrap(); + assert_eq!( + irregular_bytes_hello_world, + irregular_hello_world.to_cbor_bytes() + ); + assert_eq!( + canonical_bytes_hello_world, + irregular_hello_world.to_canonical_cbor_bytes() + ); let irregular_uint = TypeChoice::from_cbor_bytes(&irregular_bytes_uint).unwrap(); assert_eq!(irregular_bytes_uint, irregular_uint.to_cbor_bytes()); - assert_eq!(canonical_bytes_uint, irregular_uint.to_canonical_cbor_bytes()); + assert_eq!( + canonical_bytes_uint, + irregular_uint.to_canonical_cbor_bytes() + ); let irregular_text = TypeChoice::from_cbor_bytes(&irregular_bytes_text).unwrap(); assert_eq!(irregular_bytes_text, irregular_text.to_cbor_bytes()); - assert_eq!(canonical_bytes_text, irregular_text.to_canonical_cbor_bytes()); - let irregular_tagged_arr = TypeChoice::from_cbor_bytes(&irregular_bytes_tagged_arr).unwrap(); - assert_eq!(irregular_bytes_tagged_arr, irregular_tagged_arr.to_cbor_bytes()); - assert_eq!(canonical_bytes_tagged_arr, irregular_tagged_arr.to_canonical_cbor_bytes()); + assert_eq!( + canonical_bytes_text, + irregular_text.to_canonical_cbor_bytes() + ); + let irregular_tagged_arr = + TypeChoice::from_cbor_bytes(&irregular_bytes_tagged_arr).unwrap(); + assert_eq!( + irregular_bytes_tagged_arr, + irregular_tagged_arr.to_cbor_bytes() + ); + assert_eq!( + canonical_bytes_tagged_arr, + irregular_tagged_arr.to_canonical_cbor_bytes() + ); } } } @@ -396,120 +605,184 @@ mod tests { ]; for str_enc in &str_6_encodings { for def_enc in &def_encodings { - let irregular_bytes_3 = vec![ - arr_sz(1, *def_enc), - cbor_int(3, *def_enc), - ].into_iter().flatten().clone().collect::>(); - let canonical_bytes_3 = vec![ - arr_def(1), - cbor_int(3, Sz::Inline), - ].into_iter().flatten().clone().collect::>(); + let irregular_bytes_3 = vec![arr_sz(1, *def_enc), cbor_int(3, *def_enc)] + .into_iter() + .flatten() + .clone() + .collect::>(); + let canonical_bytes_3 = vec![arr_def(1), cbor_int(3, Sz::Inline)] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_tagged_2 = vec![ vec![ARR_INDEF], - cbor_tag_sz(10, *def_enc), - cbor_int(2, *def_enc), + cbor_tag_sz(10, *def_enc), + cbor_int(2, *def_enc), vec![BREAK], - ].into_iter().flatten().clone().collect::>(); - let canonical_bytes_tagged_2 = vec![ - arr_def(1), - cbor_tag(10), - cbor_int(2, Sz::Inline), - ].into_iter().flatten().clone().collect::>(); + ] + .into_iter() + .flatten() + .clone() + .collect::>(); + let canonical_bytes_tagged_2 = + vec![arr_def(1), cbor_tag(10), cbor_int(2, Sz::Inline)] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_foo = vec![ arr_sz(1, *def_enc), - cbor_tag_sz(11, *def_enc), - vec![ARR_INDEF], - cbor_int(9, *def_enc), - cbor_str_sz("potato", str_enc.clone()), - cbor_bytes_sz(vec![0xF0, 0x0D, 0xF0, 0x0D, 0xF0, 0x0D], str_enc.clone()), - vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + cbor_tag_sz(11, *def_enc), + vec![ARR_INDEF], + cbor_int(9, *def_enc), + cbor_str_sz("potato", str_enc.clone()), + cbor_bytes_sz(vec![0xF0, 0x0D, 0xF0, 0x0D, 0xF0, 0x0D], str_enc.clone()), + vec![BREAK], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let canonical_bytes_foo = vec![ arr_def(1), - cbor_tag(11), - arr_def(3), - cbor_int(9, Sz::Inline), - cbor_string("potato"), - cbor_bytes_sz(vec![0xF0, 0x0D, 0xF0, 0x0D, 0xF0, 0x0D], StringLenSz::Len(Sz::Inline)), - ].into_iter().flatten().clone().collect::>(); + cbor_tag(11), + arr_def(3), + cbor_int(9, Sz::Inline), + cbor_string("potato"), + cbor_bytes_sz( + vec![0xF0, 0x0D, 0xF0, 0x0D, 0xF0, 0x0D], + StringLenSz::Len(Sz::Inline), + ), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_inlined = vec![ arr_sz(2, *def_enc), - cbor_int(0, *def_enc), - cbor_int(10, *def_enc), - ].into_iter().flatten().clone().collect::>(); + cbor_int(0, *def_enc), + cbor_int(10, *def_enc), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let canonical_bytes_inlined = vec![ arr_def(2), - cbor_int(0, Sz::Inline), - cbor_int(10, Sz::Inline), - ].into_iter().flatten().clone().collect::>(); + cbor_int(0, Sz::Inline), + cbor_int(10, Sz::Inline), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_plain = vec![ arr_sz(2, *def_enc), - cbor_tag_sz(13, *def_enc), - cbor_int(17, *def_enc), - cbor_tag_sz(9, *def_enc), - cbor_str_sz("carrot", str_enc.clone()), - ].into_iter().flatten().clone().collect::>(); + cbor_tag_sz(13, *def_enc), + cbor_int(17, *def_enc), + cbor_tag_sz(9, *def_enc), + cbor_str_sz("carrot", str_enc.clone()), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let canonical_bytes_plain = vec![ arr_def(2), - cbor_tag(13), - cbor_int(17, Sz::Inline), - cbor_tag(9), - cbor_string("carrot"), - ].into_iter().flatten().clone().collect::>(); + cbor_tag(13), + cbor_int(17, Sz::Inline), + cbor_tag(9), + cbor_string("carrot"), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_3 = GroupChoice::from_cbor_bytes(&irregular_bytes_3).unwrap(); assert_eq!(irregular_bytes_3, irregular_3.to_cbor_bytes()); assert_eq!(canonical_bytes_3, irregular_3.to_canonical_cbor_bytes()); - let irregular_tagged_2 = GroupChoice::from_cbor_bytes(&irregular_bytes_tagged_2).unwrap(); + let irregular_tagged_2 = + GroupChoice::from_cbor_bytes(&irregular_bytes_tagged_2).unwrap(); assert_eq!(irregular_bytes_tagged_2, irregular_tagged_2.to_cbor_bytes()); - assert_eq!(canonical_bytes_tagged_2, irregular_tagged_2.to_canonical_cbor_bytes()); + assert_eq!( + canonical_bytes_tagged_2, + irregular_tagged_2.to_canonical_cbor_bytes() + ); let irregular_foo = GroupChoice::from_cbor_bytes(&irregular_bytes_foo).unwrap(); assert_eq!(irregular_bytes_foo, irregular_foo.to_cbor_bytes()); assert_eq!(canonical_bytes_foo, irregular_foo.to_canonical_cbor_bytes()); - let irregular_inlined = GroupChoice::from_cbor_bytes(&irregular_bytes_inlined).unwrap(); + let irregular_inlined = + GroupChoice::from_cbor_bytes(&irregular_bytes_inlined).unwrap(); assert_eq!(irregular_bytes_inlined, irregular_inlined.to_cbor_bytes()); - assert_eq!(canonical_bytes_inlined, irregular_inlined.to_canonical_cbor_bytes()); + assert_eq!( + canonical_bytes_inlined, + irregular_inlined.to_canonical_cbor_bytes() + ); let irregular_plain = GroupChoice::from_cbor_bytes(&irregular_bytes_plain).unwrap(); assert_eq!(irregular_bytes_plain, irregular_plain.to_cbor_bytes()); - assert_eq!(canonical_bytes_plain, irregular_plain.to_canonical_cbor_bytes()); + assert_eq!( + canonical_bytes_plain, + irregular_plain.to_canonical_cbor_bytes() + ); } } } #[test] fn cbor_in_cbor() { - let canonical_foo_bytes = vec![ + let canonical_foo_bytes = vec![ cbor_tag(11), - arr_def(3), - cbor_int(5, Sz::Inline), - cbor_string("???"), - cbor_bytes_sz(vec![0xAB, 0xCD, 0xEF], StringLenSz::Len(Sz::Inline)), - ].into_iter().flatten().clone().collect::>(); + arr_def(3), + cbor_int(5, Sz::Inline), + cbor_string("???"), + cbor_bytes_sz(vec![0xAB, 0xCD, 0xEF], StringLenSz::Len(Sz::Inline)), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let canonical_bytes = vec![ - arr_def(2), - cbor_bytes_sz(canonical_foo_bytes, StringLenSz::Len(Sz::Inline)), - cbor_bytes_sz(cbor_int(5, Sz::Inline), StringLenSz::Len(Sz::Inline)), - ].into_iter().flatten().clone().collect::>(); + arr_def(2), + cbor_bytes_sz(canonical_foo_bytes, StringLenSz::Len(Sz::Inline)), + cbor_bytes_sz(cbor_int(5, Sz::Inline), StringLenSz::Len(Sz::Inline)), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let str_3_encodings = vec![ StringLenSz::Len(Sz::Inline), StringLenSz::Len(Sz::Eight), - StringLenSz::Indefinite(vec![(2, Sz::One), (1, Sz::Four)]) + StringLenSz::Indefinite(vec![(2, Sz::One), (1, Sz::Four)]), ]; let def_encodings = vec![Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for def_enc in def_encodings.iter() { for str_enc in str_3_encodings.iter() { let irregular_foo_bytes = vec![ cbor_tag_sz(11, *def_enc), - arr_sz(3, *def_enc), - cbor_int(5, *def_enc), - cbor_str_sz("???", str_enc.clone()), - cbor_bytes_sz(vec![0xAB, 0xCD, 0xEF], str_enc.clone()) - ].into_iter().flatten().clone().collect::>(); - let foo_bytes_enc = StringLenSz::Indefinite(vec![(5, Sz::Inline), ((irregular_foo_bytes.len() - 5) as u64, Sz::Eight)]); + arr_sz(3, *def_enc), + cbor_int(5, *def_enc), + cbor_str_sz("???", str_enc.clone()), + cbor_bytes_sz(vec![0xAB, 0xCD, 0xEF], str_enc.clone()), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); + let foo_bytes_enc = StringLenSz::Indefinite(vec![ + (5, Sz::Inline), + ((irregular_foo_bytes.len() - 5) as u64, Sz::Eight), + ]); let irregular_bytes = vec![ - arr_sz(2, *def_enc), - cbor_bytes_sz(irregular_foo_bytes, foo_bytes_enc), - cbor_bytes_sz(cbor_int(5, *def_enc), StringLenSz::Len(*def_enc)), - ].into_iter().flatten().clone().collect::>(); + arr_sz(2, *def_enc), + cbor_bytes_sz(irregular_foo_bytes, foo_bytes_enc), + cbor_bytes_sz(cbor_int(5, *def_enc), StringLenSz::Len(*def_enc)), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular = CborInCbor::from_cbor_bytes(&irregular_bytes).unwrap(); assert_eq!(irregular_bytes, irregular.to_cbor_bytes()); assert_eq!(canonical_bytes, irregular.to_canonical_cbor_bytes()); diff --git a/tests/comment-dsl/tests.rs b/tests/comment-dsl/tests.rs index 20f8640..86e0dfe 100644 --- a/tests/comment-dsl/tests.rs +++ b/tests/comment-dsl/tests.rs @@ -1,6 +1,8 @@ #[cfg(test)] mod tests { use super::*; + use alloc::string::ToString; + use std::format; #[test] fn group_type() { diff --git a/tests/core/tests.rs b/tests/core/tests.rs index d528e0a..8876075 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -3,15 +3,106 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; + use std::{format, print, println}; + + fn print_cbor_types(obj_name: &str, vec: Vec) { + use cbor_event::Type; + let mut raw = cbor_event::de::Deserializer::from(vec); + let mut lens = Vec::new(); + let consume_elem = |lens: &mut Vec| { + if let Some(len) = lens.last_mut() { + if let cbor_event::LenSz::Len(n, _) = len { + *n -= 1; + } + } + }; + let reduce_depth = |lens: &mut Vec| { + while let Some(cbor_event::LenSz::Len(0, _)) = lens.last() { + lens.pop(); + println!("{}}}", "\t".repeat(lens.len())); + } + }; + println!("{} = {{", obj_name); + loop { + print!("{}", "\t".repeat(lens.len())); + match raw.cbor_type() { + Err(_) => break, + Ok(Type::UnsignedInteger) => { + let (x, sz) = raw.unsigned_integer_sz().unwrap(); + println!("UINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::NegativeInteger) => { + let (x, sz) = raw.negative_integer_sz().unwrap(); + println!("NINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Bytes) => { + let (x, sz) = raw.bytes_sz().unwrap(); + println!("BYTES({:?}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Text) => { + let (x, sz) = raw.text_sz().unwrap(); + println!("TEXT(\"{}\", {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Array) => { + let len = raw.array_sz().unwrap(); + println!("ARRAY({:?}) {{", len); + consume_elem(&mut lens); + lens.push(len); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Map) => { + let len = raw.map_sz().unwrap(); + println!("MAP({:?}) {{", len); + consume_elem(&mut lens); + lens.push(match len { + cbor_event::LenSz::Len(n, sz) => cbor_event::LenSz::Len(2 * n, sz), + cbor_event::LenSz::Indefinite => cbor_event::LenSz::Indefinite, + }); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Tag) => { + let (tag, sz) = raw.tag_sz().unwrap(); + println!("TAG({}, {:?})", tag, sz); + } + Ok(Type::Special) => { + let special = raw.special().unwrap(); + println!("SPECIAL({:?})", special); + if special == cbor_event::Special::Break { + if let Some(cbor_event::LenSz::Indefinite) = lens.last() { + lens.pop(); + reduce_depth(&mut lens); + } else { + panic!("unexpected break"); + } + } else { + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + } + } + } + println!("}}"); + } fn deser_test(orig: &T) { let orig_bytes = orig.to_cbor_bytes(); - print_cbor_types("orig", &orig_bytes); - let mut deserializer = Deserializer::from(std::io::Cursor::new(orig_bytes.clone())); + print_cbor_types("orig", orig_bytes.clone()); + let mut deserializer = Deserializer::from(orig_bytes.clone()); let deser = T::deserialize(&mut deserializer).unwrap(); - print_cbor_types("deser", &deser.to_cbor_bytes()); + print_cbor_types("deser", deser.to_cbor_bytes()); assert_eq!(orig.to_cbor_bytes(), deser.to_cbor_bytes()); - assert_eq!(deserializer.as_ref().position(), orig_bytes.len() as u64); } #[test] @@ -28,7 +119,10 @@ mod tests { #[test] fn foo2_some() { - deser_test(&Foo2::new(143546, Some(String::from("afdjfkjsiefefe").into()))); + deser_test(&Foo2::new( + 143546, + Some(String::from("afdjfkjsiefefe").into()), + )); } #[test] @@ -91,12 +185,15 @@ mod tests { #[test] fn outer() { - deser_test(&Outer::new(2143254, Plain::new(7576, String::from("wiorurri34h").into()))); + deser_test(&Outer::new( + 2143254, + Plain::new(7576, String::from("wiorurri34h").into()), + )); } #[test] fn table_arr_members() { - let mut tab = std::collections::BTreeMap::new(); + let mut tab = alloc::collections::BTreeMap::new(); tab.insert(String::from("43266556"), String::from("2k2j343")); tab.insert(String::from("213543254546565"), String::from("!!fjdj")); let mut foos = vec![ @@ -116,7 +213,7 @@ mod tests { fn type_choice_hello_world() { deser_test(&TypeChoice::Helloworld); } - + #[test] fn type_choice_uint() { deser_test(&TypeChoice::U64(53435364)); @@ -154,7 +251,10 @@ mod tests { #[test] fn group_choice_plain() { - deser_test(&GroupChoice::Plain(Plain::new(354545, String::from("fdsfdsfdg").into()))); + deser_test(&GroupChoice::Plain(Plain::new( + 354545, + String::from("fdsfdsfdg").into(), + ))); } #[test] @@ -175,9 +275,29 @@ mod tests { #[test] fn signed_ints() { - let min = SignedInts::new(u8::MIN, u16::MIN, u32::MIN, u64::MIN, i8::MIN, i16::MIN, i32::MIN, i64::MIN, u64::MIN); + let min = SignedInts::new( + u8::MIN, + u16::MIN, + u32::MIN, + u64::MIN, + i8::MIN, + i16::MIN, + i32::MIN, + i64::MIN, + u64::MIN, + ); deser_test(&min); - let max = SignedInts::new(u8::MAX, u16::MAX, u32::MAX, u64::MAX, i8::MAX, i16::MAX, i32::MAX, i64::MAX, u64::MAX); + let max = SignedInts::new( + u8::MAX, + u16::MAX, + u32::MAX, + u64::MAX, + i8::MAX, + i16::MAX, + i32::MAX, + i64::MAX, + u64::MAX, + ); deser_test(&max); } @@ -197,9 +317,12 @@ mod tests { // we can use this test compiling as a test for the presence of an alias by referencing e.g. I8::MIN // but we need to read the actual code to test that we're NOT using an alias somewhere and are indeed // using a raw rust primitive instead - let lib_rs_with_tests = std::fs::read_to_string(std::path::PathBuf::from_str("src").unwrap().join("lib.rs")).unwrap(); + let lib_rs_with_tests = + std::fs::read_to_string(std::path::PathBuf::from_str("src").unwrap().join("lib.rs")) + .unwrap(); // lib.rs includes this very test (and thus those strings we're searching for) so we need to strip that part - let lib_rs = &lib_rs_with_tests[..lib_rs_with_tests.find("#[cfg(test)]").unwrap()]; + let lib_rs = + &lib_rs_with_tests[..lib_rs_with_tests.find("#[cfg(test)]\nmod tests").unwrap()]; // these don't have @no_alias assert!(lib_rs.contains("pub type I8 = i8;")); assert!(lib_rs.contains("pub type I64 = i64;")); diff --git a/tests/deser_test b/tests/deser_test index 950518d..4250a16 100644 --- a/tests/deser_test +++ b/tests/deser_test @@ -72,94 +72,3 @@ fn cbor_float(f: f64) -> Vec { buf.write_special(cbor_event::Special::Float(f)).unwrap(); buf.finalize() } - -fn print_cbor_types(obj_name: &str, vec: &Vec) { - use cbor_event::Type; - let mut raw = cbor_event::de::Deserializer::from(std::io::Cursor::new(vec)); - let mut lens = Vec::new(); - let consume_elem = |lens: &mut Vec| { - if let Some(len) = lens.last_mut() { - if let cbor_event::LenSz::Len(n, _) = len { - *n -= 1; - } - } - }; - let reduce_depth = |lens: &mut Vec| { - while let Some(cbor_event::LenSz::Len(0, _)) = lens.last() { - lens.pop(); - println!("{}}}", "\t".repeat(lens.len())); - } - }; - println!("{} = {{", obj_name); - loop { - print!("{}", "\t".repeat(lens.len())); - match raw.cbor_type() { - Err(_) => break, - Ok(Type::UnsignedInteger) => { - let (x, sz) = raw.unsigned_integer_sz().unwrap(); - println!("UINT({}, {:?})", x, sz); - consume_elem(&mut lens); - reduce_depth(&mut lens); - }, - Ok(Type::NegativeInteger) => { - let (x, sz) = raw.negative_integer_sz().unwrap(); - println!("NINT({}, {:?})", x, sz); - consume_elem(&mut lens); - reduce_depth(&mut lens); - }, - Ok(Type::Bytes) => { - let (x, sz) = raw.bytes_sz().unwrap(); - println!("BYTES({:?}, {:?})", x, sz); - consume_elem(&mut lens); - reduce_depth(&mut lens); - }, - Ok(Type::Text) => { - let (x, sz) = raw.text_sz().unwrap(); - println!("TEXT(\"{}\", {:?})", x, sz); - consume_elem(&mut lens); - reduce_depth(&mut lens); - }, - Ok(Type::Array) => { - let len = raw.array_sz().unwrap(); - println!("ARRAY({:?}) {{", len); - consume_elem(&mut lens); - lens.push(len); - if let cbor_event::LenSz::Len(0, _sz) = len { - reduce_depth(&mut lens); - } - }, - Ok(Type::Map) => { - let len = raw.map_sz().unwrap(); - println!("MAP({:?}) {{", len); - consume_elem(&mut lens); - lens.push(match len { - cbor_event::LenSz::Len(n, sz) => cbor_event::LenSz::Len(2 * n, sz), - cbor_event::LenSz::Indefinite => cbor_event::LenSz::Indefinite, - }); - if let cbor_event::LenSz::Len(0, _sz) = len { - reduce_depth(&mut lens); - } - }, - Ok(Type::Tag) => { - let (tag, sz) = raw.tag_sz().unwrap(); - println!("TAG({}, {:?})", tag, sz); - }, - Ok(Type::Special) => { - let special = raw.special().unwrap(); - println!("SPECIAL({:?})", special); - if special == cbor_event::Special::Break { - if let Some(cbor_event::LenSz::Indefinite) = lens.last() { - lens.pop(); - reduce_depth(&mut lens); - } else { - panic!("unexpected break"); - } - } else { - consume_elem(&mut lens); - reduce_depth(&mut lens); - } - }, - } - } - println!("}}"); -} diff --git a/tests/external_json_impls b/tests/external_json_impls index 45ee0ab..3eccc53 100644 --- a/tests/external_json_impls +++ b/tests/external_json_impls @@ -12,7 +12,7 @@ impl<'de> serde::de::Deserialize<'de> for CustomWrapper { where D: serde::de::Deserializer<'de>, { - use std::str::FromStr; + use alloc::str::FromStr; let s = ::deserialize(deserializer)?; u64::from_str(&s) .map(CustomWrapper::new) diff --git a/tests/external_rust_defs b/tests/external_rust_defs index 78d4073..a6de353 100644 --- a/tests/external_rust_defs +++ b/tests/external_rust_defs @@ -16,10 +16,10 @@ impl ExternalFoo { } impl cbor_event::se::Serialize for ExternalFoo { - fn serialize<'se, W: std::io::Write>( + fn serialize<'se>( &self, - serializer: &'se mut cbor_event::se::Serializer, - ) -> cbor_event::Result<&'se mut cbor_event::se::Serializer> { + serializer: &'se mut cbor_event::se::Serializer, + ) -> cbor_event::Result<&'se mut cbor_event::se::Serializer> { serializer.write_array(cbor_event::Len::Len(3))?; serializer.write_unsigned_integer(self.index_0)?; serializer.write_text(&self.index_1)?; @@ -29,7 +29,7 @@ impl cbor_event::se::Serialize for ExternalFoo { } impl serialization::Deserialize for ExternalFoo { - fn deserialize(raw: &mut cbor_event::de::Deserializer) -> Result { + fn deserialize(raw: &mut cbor_event::de::Deserializer) -> Result { let len = raw.array()?; let mut read_len = CBORReadLen::new(len); read_len.read_elems(3)?; diff --git a/tests/external_rust_defs_compiles_with_json_preserve b/tests/external_rust_defs_compiles_with_json_preserve index bd08692..34a2906 100644 --- a/tests/external_rust_defs_compiles_with_json_preserve +++ b/tests/external_rust_defs_compiles_with_json_preserve @@ -1,7 +1,8 @@ // same as external_rust_defs, but with JSON traits + serialization code compiles with --preserve-encodings=true // as this changes the API for CBORReadLen. This code does NOT support preserving encodings - just compiles with it. -#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)] +#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)] +#[cfg_attr(feature = "std", derive(schemars::JsonSchema))] pub struct ExternalFoo { pub index_0: u64, pub index_1: String, @@ -19,10 +20,10 @@ impl ExternalFoo { } impl cbor_event::se::Serialize for ExternalFoo { - fn serialize<'se, W: std::io::Write>( + fn serialize<'se>( &self, - serializer: &'se mut cbor_event::se::Serializer, - ) -> cbor_event::Result<&'se mut cbor_event::se::Serializer> { + serializer: &'se mut cbor_event::se::Serializer, + ) -> cbor_event::Result<&'se mut cbor_event::se::Serializer> { serializer.write_array(cbor_event::Len::Len(3))?; serializer.write_unsigned_integer(self.index_0)?; serializer.write_text(&self.index_1)?; @@ -32,7 +33,7 @@ impl cbor_event::se::Serialize for ExternalFoo { } impl serialization::Deserialize for ExternalFoo { - fn deserialize(raw: &mut cbor_event::de::Deserializer) -> Result { + fn deserialize(raw: &mut cbor_event::de::Deserializer) -> Result { let len = raw.array()?; let mut read_len = CBORReadLen::new(cbor_event::LenSz::Indefinite); read_len.read_elems(3)?; diff --git a/tests/external_rust_raw_bytes_def b/tests/external_rust_raw_bytes_def index ef5dad6..e5818a3 100644 --- a/tests/external_rust_raw_bytes_def +++ b/tests/external_rust_raw_bytes_def @@ -9,7 +9,7 @@ impl RawBytesEncoding for PubKey { } fn from_raw_bytes(bytes: &[u8]) -> Result { - use std::convert::TryInto; + use core::convert::TryInto; bytes .try_into() .map(PubKey) diff --git a/tests/json/tests.rs b/tests/json/tests.rs index 8afd25e..05b43e1 100644 --- a/tests/json/tests.rs +++ b/tests/json/tests.rs @@ -3,6 +3,7 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; + use std::format; #[test] fn bytes_wrapper() { diff --git a/tests/preserve-encodings/tests.rs b/tests/preserve-encodings/tests.rs index db76713..dbad7d1 100644 --- a/tests/preserve-encodings/tests.rs +++ b/tests/preserve-encodings/tests.rs @@ -1,13 +1,105 @@ #[cfg(test)] mod tests { use super::*; - use cbor_event::{de::Deserializer, Sz, StringLenSz}; + use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; + use std::{format, print, println}; + + fn print_cbor_types(obj_name: &str, vec: Vec) { + use cbor_event::Type; + let mut raw = cbor_event::de::Deserializer::from(vec); + let mut lens = Vec::new(); + let consume_elem = |lens: &mut Vec| { + if let Some(len) = lens.last_mut() { + if let cbor_event::LenSz::Len(n, _) = len { + *n -= 1; + } + } + }; + let reduce_depth = |lens: &mut Vec| { + while let Some(cbor_event::LenSz::Len(0, _)) = lens.last() { + lens.pop(); + println!("{}}}", "\t".repeat(lens.len())); + } + }; + println!("{} = {{", obj_name); + loop { + print!("{}", "\t".repeat(lens.len())); + match raw.cbor_type() { + Err(_) => break, + Ok(Type::UnsignedInteger) => { + let (x, sz) = raw.unsigned_integer_sz().unwrap(); + println!("UINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::NegativeInteger) => { + let (x, sz) = raw.negative_integer_sz().unwrap(); + println!("NINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Bytes) => { + let (x, sz) = raw.bytes_sz().unwrap(); + println!("BYTES({:?}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Text) => { + let (x, sz) = raw.text_sz().unwrap(); + println!("TEXT(\"{}\", {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Array) => { + let len = raw.array_sz().unwrap(); + println!("ARRAY({:?}) {{", len); + consume_elem(&mut lens); + lens.push(len); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Map) => { + let len = raw.map_sz().unwrap(); + println!("MAP({:?}) {{", len); + consume_elem(&mut lens); + lens.push(match len { + cbor_event::LenSz::Len(n, sz) => cbor_event::LenSz::Len(2 * n, sz), + cbor_event::LenSz::Indefinite => cbor_event::LenSz::Indefinite, + }); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Tag) => { + let (tag, sz) = raw.tag_sz().unwrap(); + println!("TAG({}, {:?})", tag, sz); + } + Ok(Type::Special) => { + let special = raw.special().unwrap(); + println!("SPECIAL({:?})", special); + if special == cbor_event::Special::Break { + if let Some(cbor_event::LenSz::Indefinite) = lens.last() { + lens.pop(); + reduce_depth(&mut lens); + } else { + panic!("unexpected break"); + } + } else { + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + } + } + } + println!("}}"); + } fn deser_test(orig: &T) { - print_cbor_types("orig", &orig.to_cbor_bytes()); - let deser = T::deserialize(&mut Deserializer::from(std::io::Cursor::new(orig.to_cbor_bytes()))).unwrap(); - print_cbor_types("deser", &deser.to_cbor_bytes()); + print_cbor_types("orig", orig.to_cbor_bytes()); + let deser = T::deserialize(&mut Deserializer::from(orig.to_cbor_bytes())).unwrap(); + print_cbor_types("deser", deser.to_cbor_bytes()); assert_eq!(orig.to_cbor_bytes(), deser.to_cbor_bytes()); } @@ -50,49 +142,70 @@ mod tests { let indefinite_bytes = bar.to_cbor_bytes(); let default_indef_bytes = vec![ vec![MAP_INDEF], - cbor_string("foo"), - cbor_tag(13), - bar.foo.to_cbor_bytes(), - vec![0x01u8], - vec![NULL], - vec![0x05u8], - cbor_string("text"), - cbor_string("five"), - vec![0x05u8], - vec![BREAK] - ].into_iter().flatten().clone().collect::>(); + cbor_string("foo"), + cbor_tag(13), + bar.foo.to_cbor_bytes(), + vec![0x01u8], + vec![NULL], + vec![0x05u8], + cbor_string("text"), + cbor_string("five"), + vec![0x05u8], + vec![BREAK], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); assert_eq!(indefinite_bytes, default_indef_bytes); let canonical_bytes = vec![ map_def(4), - vec![0x01u8], - vec![NULL], - vec![0x05u8], - cbor_string("text"), - cbor_string("foo"), - cbor_tag(13), - bar.foo.to_cbor_bytes(), - cbor_string("five"), - vec![0x05u8], - ].into_iter().flatten().clone().collect::>(); + vec![0x01u8], + vec![NULL], + vec![0x05u8], + cbor_string("text"), + cbor_string("foo"), + cbor_tag(13), + bar.foo.to_cbor_bytes(), + cbor_string("five"), + vec![0x05u8], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let mut bar_canonical = Bar::from_cbor_bytes(&canonical_bytes).unwrap(); deser_test(&bar_canonical); - assert_eq!(bar_canonical.encodings.as_ref().unwrap().len_encoding, LenEncoding::Canonical); - assert_eq!(bar_canonical.encodings.as_ref().unwrap().orig_deser_order, vec![2, 3, 0, 4]); + assert_eq!( + bar_canonical.encodings.as_ref().unwrap().len_encoding, + LenEncoding::Canonical + ); + assert_eq!( + bar_canonical.encodings.as_ref().unwrap().orig_deser_order, + vec![2, 3, 0, 4] + ); // get rid of other info and it should be identical let str_3_encodings = vec![ StringLenSz::Len(Sz::Inline), StringLenSz::Len(Sz::Eight), - StringLenSz::Indefinite(vec![(2, Sz::One), (1, Sz::Four)]) + StringLenSz::Indefinite(vec![(2, Sz::One), (1, Sz::Four)]), ]; let str_4_encodings = vec![ StringLenSz::Indefinite(vec![(4, Sz::Inline)]), StringLenSz::Len(Sz::Two), - StringLenSz::Indefinite(vec![(1, Sz::Inline), (1, Sz::Four), (1, Sz::One), (1, Sz::Two)]), + StringLenSz::Indefinite(vec![ + (1, Sz::Inline), + (1, Sz::Four), + (1, Sz::One), + (1, Sz::Two), + ]), ]; let def_encodings = vec![Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for def_enc in def_encodings { for (str_3, str_4) in str_3_encodings.iter().zip(str_4_encodings.iter()) { - for (has_5, has_derp) in [(false, false), (false, true), (true, false), (true, true)] { + for (has_5, has_derp) in + [(false, false), (false, true), (true, false), (true, true)] + { let len = if has_5 && has_derp { 5 } else if has_5 || has_derp { @@ -103,43 +216,60 @@ mod tests { let keys = [ [ cbor_str_sz("foo", str_3.clone()), - cbor_tag_sz(13, def_enc), - bar.foo.to_cbor_bytes(), - ].into_iter().flatten().copied().collect::>(), + cbor_tag_sz(13, def_enc), + bar.foo.to_cbor_bytes(), + ] + .into_iter() + .flatten() + .copied() + .collect::>(), if has_5 { - [ - cbor_int(5, def_enc), - cbor_str_sz("text", str_4.clone()), - ].into_iter().flatten().copied().collect::>() + [cbor_int(5, def_enc), cbor_str_sz("text", str_4.clone())] + .into_iter() + .flatten() + .copied() + .collect::>() } else { vec![] }, - [ - cbor_int(1, def_enc), - vec![NULL], - ].into_iter().flatten().copied().collect::>(), + [cbor_int(1, def_enc), vec![NULL]] + .into_iter() + .flatten() + .copied() + .collect::>(), if has_derp { - [ - cbor_str_sz("derp", str_4.clone()), - cbor_int(2, def_enc), - ].into_iter().flatten().copied().collect::>() + [cbor_str_sz("derp", str_4.clone()), cbor_int(2, def_enc)] + .into_iter() + .flatten() + .copied() + .collect::>() } else { vec![] }, - [ - cbor_str_sz("five", str_4.clone()), - cbor_int(5, def_enc), - ].into_iter().flatten().copied().collect::>(), + [cbor_str_sz("five", str_4.clone()), cbor_int(5, def_enc)] + .into_iter() + .flatten() + .copied() + .collect::>(), ]; // just a subset of permutations to not take forever - for key_order in [[0, 1, 2, 3, 4], [4, 3, 2, 1, 0], [3, 1, 0, 4, 2], [0, 2, 4, 1, 3], [2, 0, 3, 4, 1]] { + for key_order in [ + [0, 1, 2, 3, 4], + [4, 3, 2, 1, 0], + [3, 1, 0, 4, 2], + [0, 2, 4, 1, 3], + [2, 0, 3, 4, 1], + ] { let mut irregular_encoding = map_sz(len, def_enc); for i in 0..5 { irregular_encoding.extend_from_slice(&keys[key_order[i]]); } - print_cbor_types("irregular_encoding", &irregular_encoding); + print_cbor_types("irregular_encoding", irregular_encoding.clone()); let irregular_bar = Bar::from_cbor_bytes(&irregular_encoding).unwrap(); - print_cbor_types("irregular_bar.to_cbor_bytes()", &irregular_bar.to_cbor_bytes()); + print_cbor_types( + "irregular_bar.to_cbor_bytes()", + irregular_bar.to_cbor_bytes(), + ); assert_eq!(irregular_bar.to_cbor_bytes(), irregular_encoding); } } @@ -161,52 +291,60 @@ mod tests { deser_test(&orig); let expected = vec![ map_def(3), - cbor_string("arr"), - arr_def(3), - vec![0x01, 0x03, 0x06], - cbor_string("arr2"), - arr_def(1), - cbor_tag(11), - arr_def(3), - vec![0x00], - cbor_string("Zero"), - vec![0x40], - cbor_string("table"), - map_def(2), - vec![0x00], - cbor_string("zero"), - vec![0x18, 0x20], - cbor_string("thirty two"), - ].into_iter().flatten().clone().collect::>(); + cbor_string("arr"), + arr_def(3), + vec![0x01, 0x03, 0x06], + cbor_string("arr2"), + arr_def(1), + cbor_tag(11), + arr_def(3), + vec![0x00], + cbor_string("Zero"), + vec![0x40], + cbor_string("table"), + map_def(2), + vec![0x00], + cbor_string("zero"), + vec![0x18, 0x20], + cbor_string("thirty two"), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); assert_eq!(orig.to_cbor_bytes(), expected); let indef_other_order = vec![ vec![MAP_INDEF], - cbor_string("arr2"), - vec![ARR_INDEF], - cbor_tag(11), - vec![ARR_INDEF], - vec![0x00], - cbor_string("Zero"), - vec![0x40], - vec![BREAK], - vec![BREAK], - cbor_string("table"), - vec![MAP_INDEF], - vec![0x18, 0x20], - cbor_string("thirty two"), - vec![0x00], - cbor_string("zero"), - vec![BREAK], - cbor_string("arr"), - vec![ARR_INDEF], - vec![0x01, 0x03, 0x06], - vec![BREAK], + cbor_string("arr2"), + vec![ARR_INDEF], + cbor_tag(11), + vec![ARR_INDEF], + vec![0x00], + cbor_string("Zero"), + vec![0x40], + vec![BREAK], + vec![BREAK], + cbor_string("table"), + vec![MAP_INDEF], + vec![0x18, 0x20], + cbor_string("thirty two"), + vec![0x00], + cbor_string("zero"), + vec![BREAK], + cbor_string("arr"), + vec![ARR_INDEF], + vec![0x01, 0x03, 0x06], + vec![BREAK], vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let mut other_order = TableArrMembers::from_cbor_bytes(&indef_other_order).unwrap(); assert_eq!(other_order.to_cbor_bytes(), indef_other_order); deser_test(&other_order); - + assert!(orig.encodings.is_none()); let other_order_encodings = other_order.encodings.unwrap(); @@ -214,8 +352,14 @@ mod tests { assert_eq!(other_order_encodings.len_encoding, LenEncoding::Indefinite); assert_eq!(other_order_encodings.arr_encoding, LenEncoding::Indefinite); assert_eq!(other_order_encodings.arr2_encoding, LenEncoding::Indefinite); - assert_eq!(other_order.arr2[0].encodings.as_ref().unwrap().len_encoding, LenEncoding::Indefinite); - assert_eq!(other_order_encodings.table_encoding, LenEncoding::Indefinite); + assert_eq!( + other_order.arr2[0].encodings.as_ref().unwrap().len_encoding, + LenEncoding::Indefinite + ); + assert_eq!( + other_order_encodings.table_encoding, + LenEncoding::Indefinite + ); } #[test] @@ -223,53 +367,62 @@ mod tests { let str_3_encodings = vec![ StringLenSz::Len(Sz::Inline), StringLenSz::Len(Sz::Eight), - StringLenSz::Indefinite(vec![(1, Sz::Two), (2, Sz::Four)]) + StringLenSz::Indefinite(vec![(1, Sz::Two), (2, Sz::Four)]), ]; let str_4_encodings = vec![ StringLenSz::Indefinite(vec![(4, Sz::Inline)]), StringLenSz::Len(Sz::Two), - StringLenSz::Indefinite(vec![(1, Sz::Eight), (1, Sz::Inline), (1, Sz::Inline), (1, Sz::Two)]), + StringLenSz::Indefinite(vec![ + (1, Sz::Eight), + (1, Sz::Inline), + (1, Sz::Inline), + (1, Sz::Two), + ]), ]; let def_encodings = vec![Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for def_enc in def_encodings { for (str_3, str_4) in str_3_encodings.iter().zip(str_4_encodings.iter()) { let irregular_bytes = vec![ arr_sz(1, def_enc), - vec![MAP_INDEF], - cbor_tag_sz(14, def_enc), - cbor_bytes_sz(vec![0xBA, 0xAD, 0xF0, 0x0D], str_4.clone()), - map_sz(1, def_enc), - cbor_int(10, def_enc), - map_sz(1, def_enc), - cbor_tag_sz(9, def_enc), - cbor_int(0, def_enc), - arr_sz(2, def_enc), - cbor_tag_sz(18, def_enc), - arr_sz(0, def_enc), - cbor_tag_sz(18, def_enc), - vec![ARR_INDEF], - cbor_str_sz("test", str_4.clone()), - cbor_str_sz("XYZ", str_3.clone()), - cbor_str_sz("ABC", str_3.clone()), - vec![BREAK], - cbor_tag_sz(14, def_enc), - cbor_bytes_sz(vec![0xAA, 0xBB, 0xCC], str_3.clone()), - vec![MAP_INDEF], - cbor_int(5, def_enc), - vec![MAP_INDEF], - vec![BREAK], - cbor_int(3, def_enc), - map_sz(1, def_enc), - cbor_tag_sz(9, def_enc), - cbor_int(2, def_enc), - vec![ARR_INDEF], - cbor_tag_sz(18, def_enc), - arr_sz(1, def_enc), - cbor_str_sz("cbor", str_4.clone()), - vec![BREAK], - vec![BREAK], - vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + vec![MAP_INDEF], + cbor_tag_sz(14, def_enc), + cbor_bytes_sz(vec![0xBA, 0xAD, 0xF0, 0x0D], str_4.clone()), + map_sz(1, def_enc), + cbor_int(10, def_enc), + map_sz(1, def_enc), + cbor_tag_sz(9, def_enc), + cbor_int(0, def_enc), + arr_sz(2, def_enc), + cbor_tag_sz(18, def_enc), + arr_sz(0, def_enc), + cbor_tag_sz(18, def_enc), + vec![ARR_INDEF], + cbor_str_sz("test", str_4.clone()), + cbor_str_sz("XYZ", str_3.clone()), + cbor_str_sz("ABC", str_3.clone()), + vec![BREAK], + cbor_tag_sz(14, def_enc), + cbor_bytes_sz(vec![0xAA, 0xBB, 0xCC], str_3.clone()), + vec![MAP_INDEF], + cbor_int(5, def_enc), + vec![MAP_INDEF], + vec![BREAK], + cbor_int(3, def_enc), + map_sz(1, def_enc), + cbor_tag_sz(9, def_enc), + cbor_int(2, def_enc), + vec![ARR_INDEF], + cbor_tag_sz(18, def_enc), + arr_sz(1, def_enc), + cbor_str_sz("cbor", str_4.clone()), + vec![BREAK], + vec![BREAK], + vec![BREAK], + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular = DeeplyNested::from_cbor_bytes(&irregular_bytes).unwrap(); assert_eq!(irregular_bytes, irregular.to_cbor_bytes()); } @@ -282,15 +435,28 @@ mod tests { StringLenSz::Len(Sz::One), StringLenSz::Len(Sz::Four), StringLenSz::Indefinite(vec![(12, Sz::Two), (12, Sz::One)]), - StringLenSz::Indefinite(vec![(0, Sz::Inline), (4, Sz::Inline), (20, Sz::Four), (0, Sz::Eight)]), + StringLenSz::Indefinite(vec![ + (0, Sz::Inline), + (4, Sz::Inline), + (20, Sz::Four), + (0, Sz::Eight), + ]), ]; for str_enc in str_24_encodings { let irregular_bytes = cbor_str_sz("-*=[0123456789ABCDEF]=*-", str_enc); let irregular = String64::from_cbor_bytes(&irregular_bytes).unwrap(); assert_eq!(irregular_bytes, irregular.to_cbor_bytes()); } - let _ = String64::from_cbor_bytes(&cbor_str_sz(&(0..64).map(|_| "?").collect::(), StringLenSz::Len(Sz::Two))).unwrap(); - assert!(String64::from_cbor_bytes(&cbor_str_sz(&(0..65).map(|_| "?").collect::(), StringLenSz::Len(Sz::Two))).is_err()); + let _ = String64::from_cbor_bytes(&cbor_str_sz( + &(0..64).map(|_| "?").collect::(), + StringLenSz::Len(Sz::Two), + )) + .unwrap(); + assert!(String64::from_cbor_bytes(&cbor_str_sz( + &(0..65).map(|_| "?").collect::(), + StringLenSz::Len(Sz::Two) + )) + .is_err()); } #[test] @@ -300,35 +466,84 @@ mod tests { StringLenSz::Len(Sz::One), StringLenSz::Len(Sz::Four), StringLenSz::Indefinite(vec![(12, Sz::Two), (12, Sz::One)]), - StringLenSz::Indefinite(vec![(0, Sz::Inline), (4, Sz::Inline), (20, Sz::Four), (0, Sz::Eight)]), + StringLenSz::Indefinite(vec![ + (0, Sz::Inline), + (4, Sz::Inline), + (20, Sz::Four), + (0, Sz::Eight), + ]), ]; let def_encodings = vec![Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for str_enc in &str_24_encodings { for def_enc in &def_encodings { let irregular_bytes = vec![ cbor_tag_sz(7, *def_enc), - cbor_str_sz("-*=[0123456789ABCDEF]=*-", str_enc.clone()), - ].into_iter().flatten().clone().collect::>(); + cbor_str_sz("-*=[0123456789ABCDEF]=*-", str_enc.clone()), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular = String1632::from_cbor_bytes(&irregular_bytes).unwrap(); assert_eq!(irregular_bytes, irregular.to_cbor_bytes()); } } - let _ = String1632::from_cbor_bytes(&vec![ - cbor_tag_sz(7, Sz::One), - cbor_str_sz(&(0..16).map(|_| "?").collect::(), StringLenSz::Len(Sz::One)), - ].into_iter().flatten().clone().collect::>()).unwrap(); - let _ = String1632::from_cbor_bytes(&vec![ - cbor_tag_sz(7, Sz::Two), - cbor_str_sz(&(0..32).map(|_| "?").collect::(), StringLenSz::Len(Sz::Two)), - ].into_iter().flatten().clone().collect::>()).unwrap(); - assert!(String1632::from_cbor_bytes(&vec![ - cbor_tag_sz(7, Sz::Inline), - cbor_str_sz(&(0..15).map(|_| "?").collect::(), StringLenSz::Len(Sz::Inline)), - ].into_iter().flatten().clone().collect::>()).is_err()); - assert!(String1632::from_cbor_bytes(&vec![ - cbor_tag_sz(7, Sz::Eight), - cbor_str_sz(&(0..33).map(|_| "?").collect::(), StringLenSz::Len(Sz::Eight)), - ].into_iter().flatten().clone().collect::>()).is_err()); + let _ = String1632::from_cbor_bytes( + &vec![ + cbor_tag_sz(7, Sz::One), + cbor_str_sz( + &(0..16).map(|_| "?").collect::(), + StringLenSz::Len(Sz::One), + ), + ] + .into_iter() + .flatten() + .clone() + .collect::>(), + ) + .unwrap(); + let _ = String1632::from_cbor_bytes( + &vec![ + cbor_tag_sz(7, Sz::Two), + cbor_str_sz( + &(0..32).map(|_| "?").collect::(), + StringLenSz::Len(Sz::Two), + ), + ] + .into_iter() + .flatten() + .clone() + .collect::>(), + ) + .unwrap(); + assert!(String1632::from_cbor_bytes( + &vec![ + cbor_tag_sz(7, Sz::Inline), + cbor_str_sz( + &(0..15).map(|_| "?").collect::(), + StringLenSz::Len(Sz::Inline) + ), + ] + .into_iter() + .flatten() + .clone() + .collect::>() + ) + .is_err()); + assert!(String1632::from_cbor_bytes( + &vec![ + cbor_tag_sz(7, Sz::Eight), + cbor_str_sz( + &(0..33).map(|_| "?").collect::(), + StringLenSz::Len(Sz::Eight) + ), + ] + .into_iter() + .flatten() + .clone() + .collect::>() + ) + .is_err()); } #[test] @@ -348,20 +563,32 @@ mod tests { let irregular_bytes_text = cbor_str_sz("abcdefghijk", str_enc.clone()); let irregular_bytes_tagged_arr = vec![ cbor_tag_sz(16, *def_enc), - arr_sz(2, *def_enc), - cbor_int(1, *def_enc), - cbor_int(3, *def_enc), - ].into_iter().flatten().clone().collect::>(); + arr_sz(2, *def_enc), + cbor_int(1, *def_enc), + cbor_int(3, *def_enc), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_0 = TypeChoice::from_cbor_bytes(&irregular_bytes_0).unwrap(); assert_eq!(irregular_bytes_0, irregular_0.to_cbor_bytes()); - let irregular_hello_world = TypeChoice::from_cbor_bytes(&irregular_bytes_hello_world).unwrap(); - assert_eq!(irregular_bytes_hello_world, irregular_hello_world.to_cbor_bytes()); + let irregular_hello_world = + TypeChoice::from_cbor_bytes(&irregular_bytes_hello_world).unwrap(); + assert_eq!( + irregular_bytes_hello_world, + irregular_hello_world.to_cbor_bytes() + ); let irregular_uint = TypeChoice::from_cbor_bytes(&irregular_bytes_uint).unwrap(); assert_eq!(irregular_bytes_uint, irregular_uint.to_cbor_bytes()); let irregular_text = TypeChoice::from_cbor_bytes(&irregular_bytes_text).unwrap(); assert_eq!(irregular_bytes_text, irregular_text.to_cbor_bytes()); - let irregular_tagged_arr = TypeChoice::from_cbor_bytes(&irregular_bytes_tagged_arr).unwrap(); - assert_eq!(irregular_bytes_tagged_arr, irregular_tagged_arr.to_cbor_bytes()); + let irregular_tagged_arr = + TypeChoice::from_cbor_bytes(&irregular_bytes_tagged_arr).unwrap(); + assert_eq!( + irregular_bytes_tagged_arr, + irregular_tagged_arr.to_cbor_bytes() + ); } } } @@ -490,11 +717,15 @@ mod tests { for enum_value in &enum_values { let irregular_bytes = vec![ arr_sz(2, *def_enc), - // CEnum - cbor_int(*enum_value, *def_enc), - // TypeChoice - cbor_int(0, *def_enc), - ].into_iter().flatten().clone().collect::>(); + // CEnum + cbor_int(*enum_value, *def_enc), + // TypeChoice + cbor_int(0, *def_enc), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); } } } @@ -510,43 +741,62 @@ mod tests { ]; for str_enc in &str_6_encodings { for def_enc in &def_encodings { - let irregular_bytes_3 = vec![ - arr_sz(1, *def_enc), - cbor_int(3, *def_enc), - ].into_iter().flatten().clone().collect::>(); + let irregular_bytes_3 = vec![arr_sz(1, *def_enc), cbor_int(3, *def_enc)] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_tagged_2 = vec![ arr_sz(1, *def_enc), - cbor_tag_sz(10, *def_enc), - cbor_int(2, *def_enc), - ].into_iter().flatten().clone().collect::>(); + cbor_tag_sz(10, *def_enc), + cbor_int(2, *def_enc), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_foo = vec![ vec![ARR_INDEF], - cbor_tag_sz(11, *def_enc), - arr_sz(3, *def_enc), - cbor_int(9, *def_enc), - cbor_str_sz("potato", str_enc.clone()), - cbor_bytes_sz(vec![0xF0, 0x0D, 0xF0, 0x0D, 0xF0, 0x0D], str_enc.clone()), + cbor_tag_sz(11, *def_enc), + arr_sz(3, *def_enc), + cbor_int(9, *def_enc), + cbor_str_sz("potato", str_enc.clone()), + cbor_bytes_sz(vec![0xF0, 0x0D, 0xF0, 0x0D, 0xF0, 0x0D], str_enc.clone()), vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_inlined = vec![ arr_sz(2, *def_enc), - cbor_int(0, *def_enc), - cbor_int(10, *def_enc), - ].into_iter().flatten().clone().collect::>(); + cbor_int(0, *def_enc), + cbor_int(10, *def_enc), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_bytes_plain = vec![ arr_sz(2, *def_enc), - cbor_tag_sz(13, *def_enc), - cbor_int(17, *def_enc), - cbor_tag_sz(9, *def_enc), - cbor_str_sz("carrot", str_enc.clone()), - ].into_iter().flatten().clone().collect::>(); + cbor_tag_sz(13, *def_enc), + cbor_int(17, *def_enc), + cbor_tag_sz(9, *def_enc), + cbor_str_sz("carrot", str_enc.clone()), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_3 = GroupChoice::from_cbor_bytes(&irregular_bytes_3).unwrap(); assert_eq!(irregular_bytes_3, irregular_3.to_cbor_bytes()); - let irregular_tagged_2 = GroupChoice::from_cbor_bytes(&irregular_bytes_tagged_2).unwrap(); + let irregular_tagged_2 = + GroupChoice::from_cbor_bytes(&irregular_bytes_tagged_2).unwrap(); assert_eq!(irregular_bytes_tagged_2, irregular_tagged_2.to_cbor_bytes()); let irregular_foo = GroupChoice::from_cbor_bytes(&irregular_bytes_foo).unwrap(); assert_eq!(irregular_bytes_foo, irregular_foo.to_cbor_bytes()); - let irregular_inlined = GroupChoice::from_cbor_bytes(&irregular_bytes_inlined).unwrap(); + let irregular_inlined = + GroupChoice::from_cbor_bytes(&irregular_bytes_inlined).unwrap(); assert_eq!(irregular_bytes_inlined, irregular_inlined.to_cbor_bytes()); let irregular_plain = GroupChoice::from_cbor_bytes(&irregular_bytes_plain).unwrap(); assert_eq!(irregular_bytes_plain, irregular_plain.to_cbor_bytes()); @@ -559,26 +809,37 @@ mod tests { let str_3_encodings = vec![ StringLenSz::Len(Sz::Inline), StringLenSz::Len(Sz::Eight), - StringLenSz::Indefinite(vec![(2, Sz::One), (1, Sz::Four)]) + StringLenSz::Indefinite(vec![(2, Sz::One), (1, Sz::Four)]), ]; let def_encodings = vec![Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for def_enc in def_encodings.iter() { for str_enc in str_3_encodings.iter() { let irregular_foo_bytes = vec![ cbor_tag_sz(11, *def_enc), - arr_sz(3, *def_enc), - cbor_int(5, *def_enc), - cbor_str_sz("???", str_enc.clone()), - cbor_bytes_sz(vec![0xAB, 0xCD, 0xEF], str_enc.clone()) - ].into_iter().flatten().clone().collect::>(); - let foo_bytes_enc = StringLenSz::Indefinite(vec![(5, Sz::Inline), ((irregular_foo_bytes.len() - 5) as u64, Sz::Eight)]); + arr_sz(3, *def_enc), + cbor_int(5, *def_enc), + cbor_str_sz("???", str_enc.clone()), + cbor_bytes_sz(vec![0xAB, 0xCD, 0xEF], str_enc.clone()), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); + let foo_bytes_enc = StringLenSz::Indefinite(vec![ + (5, Sz::Inline), + ((irregular_foo_bytes.len() - 5) as u64, Sz::Eight), + ]); let irregular_bytes = vec![ - arr_sz(3, *def_enc), - cbor_bytes_sz(irregular_foo_bytes.clone(), foo_bytes_enc.clone()), - cbor_bytes_sz(cbor_int(5, *def_enc), StringLenSz::Len(*def_enc)), - cbor_tag_sz(20, *def_enc), - cbor_bytes_sz(irregular_foo_bytes, foo_bytes_enc), - ].into_iter().flatten().clone().collect::>(); + arr_sz(3, *def_enc), + cbor_bytes_sz(irregular_foo_bytes.clone(), foo_bytes_enc.clone()), + cbor_bytes_sz(cbor_int(5, *def_enc), StringLenSz::Len(*def_enc)), + cbor_tag_sz(20, *def_enc), + cbor_bytes_sz(irregular_foo_bytes, foo_bytes_enc), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular = CborInCbor::from_cbor_bytes(&irregular_bytes).unwrap(); assert_eq!(irregular_bytes, irregular.to_cbor_bytes()); } @@ -587,11 +848,35 @@ mod tests { #[test] fn signed_ints() { - use std::cmp::min; - let umins = [0i128, u8::MIN as i128, u16::MIN as i128, u32::MIN as i128, u64::MIN as i128]; - let umaxs = [23i128, u8::MAX as i128, u16::MAX as i128, u32::MAX as i128, u64::MAX as i128]; - let imins = [-24i128, i8::MIN as i128, i16::MIN as i128, i32::MIN as i128, i64::MIN as i128]; - let imaxs = [-1i128, i8::MAX as i128, i16::MAX as i128, i32::MAX as i128, i64::MAX as i128]; + use core::cmp::min; + let umins = [ + 0i128, + u8::MIN as i128, + u16::MIN as i128, + u32::MIN as i128, + u64::MIN as i128, + ]; + let umaxs = [ + 23i128, + u8::MAX as i128, + u16::MAX as i128, + u32::MAX as i128, + u64::MAX as i128, + ]; + let imins = [ + -24i128, + i8::MIN as i128, + i16::MIN as i128, + i32::MIN as i128, + i64::MIN as i128, + ]; + let imaxs = [ + -1i128, + i8::MAX as i128, + i16::MAX as i128, + i32::MAX as i128, + i64::MAX as i128, + ]; let def_encodings = [Sz::Inline, Sz::One, Sz::Two, Sz::Four, Sz::Eight]; for i in 0..5 { let i_8 = min(1, i); @@ -600,45 +885,53 @@ mod tests { let i_64 = min(4, i); let irregular_bytes_min = vec![ vec![ARR_INDEF], - // uints - cbor_int(umins[i_8], def_encodings[i]), - cbor_int(umins[i_16], def_encodings[i]), - cbor_int(umins[i_32], def_encodings[i]), - cbor_int(umins[i_64], def_encodings[i]), - // ints - cbor_int(imins[i_8], def_encodings[i]), - cbor_int(imins[i_16], def_encodings[i]), - cbor_int(imins[i_32], def_encodings[i]), - cbor_int(imins[i_64], def_encodings[i]), - // nint - cbor_int(-1 - umins[i_64], def_encodings[i]), - // u64 max const - cbor_int(u64::MAX as i128, Sz::Eight), - // i64 min const - cbor_int(i64::MIN as i128, Sz::Eight), + // uints + cbor_int(umins[i_8], def_encodings[i]), + cbor_int(umins[i_16], def_encodings[i]), + cbor_int(umins[i_32], def_encodings[i]), + cbor_int(umins[i_64], def_encodings[i]), + // ints + cbor_int(imins[i_8], def_encodings[i]), + cbor_int(imins[i_16], def_encodings[i]), + cbor_int(imins[i_32], def_encodings[i]), + cbor_int(imins[i_64], def_encodings[i]), + // nint + cbor_int(-1 - umins[i_64], def_encodings[i]), + // u64 max const + cbor_int(u64::MAX as i128, Sz::Eight), + // i64 min const + cbor_int(i64::MIN as i128, Sz::Eight), vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_min = SignedInts::from_cbor_bytes(&irregular_bytes_min).unwrap(); assert_eq!(irregular_bytes_min, irregular_min.to_cbor_bytes()); let irregular_bytes_max = vec![ arr_sz(11, def_encodings[i]), - // uints - cbor_int(umaxs[i_8], def_encodings[i]), - cbor_int(umaxs[i_16], def_encodings[i]), - cbor_int(umaxs[i_32], def_encodings[i]), - cbor_int(umaxs[i_64], def_encodings[i]), - // ints - cbor_int(imaxs[i_8], def_encodings[i]), - cbor_int(imaxs[i_16], def_encodings[i]), - cbor_int(imaxs[i_32], def_encodings[i]), - cbor_int(imaxs[i_64], def_encodings[i]), - // nint - cbor_int(-1 - umaxs[i_64], def_encodings[i]), - // u64 max const - cbor_int(u64::MAX as i128, Sz::Eight), - // i64 min const - cbor_int(i64::MIN as i128, Sz::Eight), - ].into_iter().flatten().clone().collect::>(); + // uints + cbor_int(umaxs[i_8], def_encodings[i]), + cbor_int(umaxs[i_16], def_encodings[i]), + cbor_int(umaxs[i_32], def_encodings[i]), + cbor_int(umaxs[i_64], def_encodings[i]), + // ints + cbor_int(imaxs[i_8], def_encodings[i]), + cbor_int(imaxs[i_16], def_encodings[i]), + cbor_int(imaxs[i_32], def_encodings[i]), + cbor_int(imaxs[i_64], def_encodings[i]), + // nint + cbor_int(-1 - umaxs[i_64], def_encodings[i]), + // u64 max const + cbor_int(u64::MAX as i128, Sz::Eight), + // i64 min const + cbor_int(i64::MIN as i128, Sz::Eight), + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular_max = SignedInts::from_cbor_bytes(&irregular_bytes_max).unwrap(); assert_eq!(irregular_bytes_max, irregular_max.to_cbor_bytes()); } @@ -656,29 +949,37 @@ mod tests { let bools = [(false, true), (true, false), (true, true)]; for str_enc in &str_3_encodings { for def_enc in &def_encodings { - for ((key_1_present, key_1_default), (key_2_present, key_2_default)) in bools.iter().zip(bools.iter()) { + for ((key_1_present, key_1_default), (key_2_present, key_2_default)) in + bools.iter().zip(bools.iter()) + { let value_1: u64 = if *key_1_default { 1337 } else { 2 }; let value_2 = if *key_2_default { "two" } else { "one" }; let irregular_bytes = vec![ vec![MAP_INDEF], - if *key_1_present { - vec![ - cbor_int(1, *def_enc), - cbor_int(value_1 as i128, Sz::Two), - ].into_iter().flatten().clone().collect::>() - } else { - vec![] - }, - if *key_2_present { - vec![ - cbor_int(2, *def_enc), - cbor_str_sz(value_2, str_enc.clone()), - ].into_iter().flatten().clone().collect::>() - } else { - vec![] - }, + if *key_1_present { + vec![cbor_int(1, *def_enc), cbor_int(value_1 as i128, Sz::Two)] + .into_iter() + .flatten() + .clone() + .collect::>() + } else { + vec![] + }, + if *key_2_present { + vec![cbor_int(2, *def_enc), cbor_str_sz(value_2, str_enc.clone())] + .into_iter() + .flatten() + .clone() + .collect::>() + } else { + vec![] + }, vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + ] + .into_iter() + .flatten() + .clone() + .collect::>(); let irregular = MapWithDefaults::from_cbor_bytes(&irregular_bytes).unwrap(); assert_eq!(irregular_bytes, irregular.to_cbor_bytes()); assert_eq!(irregular.key_1, value_1); diff --git a/tests/raw-bytes-preserve/tests.rs b/tests/raw-bytes-preserve/tests.rs index d0e4c35..4fe8a6f 100644 --- a/tests/raw-bytes-preserve/tests.rs +++ b/tests/raw-bytes-preserve/tests.rs @@ -3,6 +3,7 @@ mod tests { use super::*; use cbor_event::{Sz, StringLenSz, de::Deserializer}; use serialization::Deserialize; + use std::format; #[test] fn foo() { diff --git a/tests/raw-bytes/tests.rs b/tests/raw-bytes/tests.rs index bdc65a3..acd8641 100644 --- a/tests/raw-bytes/tests.rs +++ b/tests/raw-bytes/tests.rs @@ -3,15 +3,106 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; + use std::{format, print, println}; + + fn print_cbor_types(obj_name: &str, vec: Vec) { + use cbor_event::Type; + let mut raw = cbor_event::de::Deserializer::from(vec); + let mut lens = Vec::new(); + let consume_elem = |lens: &mut Vec| { + if let Some(len) = lens.last_mut() { + if let cbor_event::LenSz::Len(n, _) = len { + *n -= 1; + } + } + }; + let reduce_depth = |lens: &mut Vec| { + while let Some(cbor_event::LenSz::Len(0, _)) = lens.last() { + lens.pop(); + println!("{}}}", "\t".repeat(lens.len())); + } + }; + println!("{} = {{", obj_name); + loop { + print!("{}", "\t".repeat(lens.len())); + match raw.cbor_type() { + Err(_) => break, + Ok(Type::UnsignedInteger) => { + let (x, sz) = raw.unsigned_integer_sz().unwrap(); + println!("UINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::NegativeInteger) => { + let (x, sz) = raw.negative_integer_sz().unwrap(); + println!("NINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Bytes) => { + let (x, sz) = raw.bytes_sz().unwrap(); + println!("BYTES({:?}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Text) => { + let (x, sz) = raw.text_sz().unwrap(); + println!("TEXT(\"{}\", {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Array) => { + let len = raw.array_sz().unwrap(); + println!("ARRAY({:?}) {{", len); + consume_elem(&mut lens); + lens.push(len); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Map) => { + let len = raw.map_sz().unwrap(); + println!("MAP({:?}) {{", len); + consume_elem(&mut lens); + lens.push(match len { + cbor_event::LenSz::Len(n, sz) => cbor_event::LenSz::Len(2 * n, sz), + cbor_event::LenSz::Indefinite => cbor_event::LenSz::Indefinite, + }); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Tag) => { + let (tag, sz) = raw.tag_sz().unwrap(); + println!("TAG({}, {:?})", tag, sz); + } + Ok(Type::Special) => { + let special = raw.special().unwrap(); + println!("SPECIAL({:?})", special); + if special == cbor_event::Special::Break { + if let Some(cbor_event::LenSz::Indefinite) = lens.last() { + lens.pop(); + reduce_depth(&mut lens); + } else { + panic!("unexpected break"); + } + } else { + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + } + } + } + println!("}}"); + } fn deser_test(orig: &T) { let orig_bytes = orig.to_cbor_bytes(); - print_cbor_types("orig", &orig_bytes); - let mut deserializer = Deserializer::from(std::io::Cursor::new(orig_bytes.clone())); + print_cbor_types("orig", orig_bytes.clone()); + let mut deserializer = Deserializer::from(orig_bytes.clone()); let deser = T::deserialize(&mut deserializer).unwrap(); - print_cbor_types("deser", &deser.to_cbor_bytes()); + print_cbor_types("deser", deser.to_cbor_bytes()); assert_eq!(orig.to_cbor_bytes(), deser.to_cbor_bytes()); - assert_eq!(deserializer.as_ref().position(), orig_bytes.len() as u64); } #[test] diff --git a/tests/rust-wasm-split/tests.rs b/tests/rust-wasm-split/tests.rs index 102d637..880a2fa 100644 --- a/tests/rust-wasm-split/tests.rs +++ b/tests/rust-wasm-split/tests.rs @@ -3,11 +3,103 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; + use std::{format, print, println}; + + fn print_cbor_types(obj_name: &str, vec: Vec) { + use cbor_event::Type; + let mut raw = cbor_event::de::Deserializer::from(vec); + let mut lens = Vec::new(); + let consume_elem = |lens: &mut Vec| { + if let Some(len) = lens.last_mut() { + if let cbor_event::LenSz::Len(n, _) = len { + *n -= 1; + } + } + }; + let reduce_depth = |lens: &mut Vec| { + while let Some(cbor_event::LenSz::Len(0, _)) = lens.last() { + lens.pop(); + println!("{}}}", "\t".repeat(lens.len())); + } + }; + println!("{} = {{", obj_name); + loop { + print!("{}", "\t".repeat(lens.len())); + match raw.cbor_type() { + Err(_) => break, + Ok(Type::UnsignedInteger) => { + let (x, sz) = raw.unsigned_integer_sz().unwrap(); + println!("UINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::NegativeInteger) => { + let (x, sz) = raw.negative_integer_sz().unwrap(); + println!("NINT({}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Bytes) => { + let (x, sz) = raw.bytes_sz().unwrap(); + println!("BYTES({:?}, {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Text) => { + let (x, sz) = raw.text_sz().unwrap(); + println!("TEXT(\"{}\", {:?})", x, sz); + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + Ok(Type::Array) => { + let len = raw.array_sz().unwrap(); + println!("ARRAY({:?}) {{", len); + consume_elem(&mut lens); + lens.push(len); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Map) => { + let len = raw.map_sz().unwrap(); + println!("MAP({:?}) {{", len); + consume_elem(&mut lens); + lens.push(match len { + cbor_event::LenSz::Len(n, sz) => cbor_event::LenSz::Len(2 * n, sz), + cbor_event::LenSz::Indefinite => cbor_event::LenSz::Indefinite, + }); + if let cbor_event::LenSz::Len(0, _sz) = len { + reduce_depth(&mut lens); + } + } + Ok(Type::Tag) => { + let (tag, sz) = raw.tag_sz().unwrap(); + println!("TAG({}, {:?})", tag, sz); + } + Ok(Type::Special) => { + let special = raw.special().unwrap(); + println!("SPECIAL({:?})", special); + if special == cbor_event::Special::Break { + if let Some(cbor_event::LenSz::Indefinite) = lens.last() { + lens.pop(); + reduce_depth(&mut lens); + } else { + panic!("unexpected break"); + } + } else { + consume_elem(&mut lens); + reduce_depth(&mut lens); + } + } + } + } + println!("}}"); + } fn deser_test(orig: &T) { - print_cbor_types("orig", &orig.to_cbor_bytes()); - let deser = T::deserialize(&mut Deserializer::from(std::io::Cursor::new(orig.to_cbor_bytes()))).unwrap(); - print_cbor_types("deser", &deser.to_cbor_bytes()); + print_cbor_types("orig", orig.to_cbor_bytes()); + let deser = T::deserialize(&mut Deserializer::from(orig.to_cbor_bytes())).unwrap(); + print_cbor_types("deser", deser.to_cbor_bytes()); assert_eq!(orig.to_cbor_bytes(), deser.to_cbor_bytes()); } @@ -28,7 +120,10 @@ mod tests { #[test] fn bar() { - deser_test(&Bar::new(Foo::new(436, String::from("jfkdf"), vec![6, 4]), None)); + deser_test(&Bar::new( + Foo::new(436, String::from("jfkdf"), vec![6, 4]), + None, + )); } #[test] @@ -38,7 +133,10 @@ mod tests { #[test] fn outer() { - deser_test(&Outer::new(2143254, Plain::new(7576, String::from("wiorurri34h")))); + deser_test(&Outer::new( + 2143254, + Plain::new(7576, String::from("wiorurri34h")), + )); } #[test] @@ -50,7 +148,7 @@ mod tests { fn type_choice_hello_world() { deser_test(&TypeChoice::Helloworld); } - + #[test] fn type_choice_uint() { deser_test(&TypeChoice::U64(53435364)); @@ -83,6 +181,9 @@ mod tests { #[test] fn group_choice_plain() { - deser_test(&GroupChoice::Plain(Plain::new(354545, String::from("fdsfdsfdg")))); + deser_test(&GroupChoice::Plain(Plain::new( + 354545, + String::from("fdsfdsfdg"), + ))); } }