From aa9a83b0f68c013c16b1d4b73b703ae8d6230432 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Fri, 3 Mar 2023 10:55:45 +0100 Subject: [PATCH 01/25] Use no_std branch of cbor_event --- Cargo.lock | 3 +-- Cargo.toml | 2 +- static/Cargo_rust.toml | 2 +- static/Cargo_wasm.toml | 2 +- 4 files changed, 4 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7547b80..4200360 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -110,8 +110,7 @@ checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535" [[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/SimonIT/cbor_event?branch=no_std#c3c36ab13d3efe3c960bae5ff7b65cb1d7032aac" [[package]] name = "cc" diff --git a/Cargo.toml b/Cargo.toml index 54877fc..d7ac228 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ default = ["which-rustfmt"] which-rustfmt = ["which"] [dependencies] -cbor_event = "2.4.0" +cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } cddl = "0.9.1" clap = { version = "4.1.4", features = ["derive"] } codegen = { git = "https://github.com/dcSpark/codegen", branch = "master" } diff --git a/static/Cargo_rust.toml b/static/Cargo_rust.toml index 8a1c63e..4fc830a 100644 --- a/static/Cargo_rust.toml +++ b/static/Cargo_rust.toml @@ -7,4 +7,4 @@ edition = "2018" crate-type = ["cdylib", "rlib"] [dependencies] -cbor_event = "2.4.0" +cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } diff --git a/static/Cargo_wasm.toml b/static/Cargo_wasm.toml index 9bad5bb..63ef223 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" +cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } wasm-bindgen = { version = "0.2", features=["serde-serialize"] } linked-hash-map = "0.5.3" From 351165b79cc6b76d78b062b4086e561dffd3083c Mon Sep 17 00:00:00 2001 From: SimonIT Date: Fri, 3 Mar 2023 11:34:49 +0100 Subject: [PATCH 02/25] Set no_std flag for rust project --- src/generation.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/generation.rs b/src/generation.rs index fb097d5..8fc7926 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -699,7 +699,8 @@ impl GenerationScope { // rust self.rust_lib() - .raw("#![allow(clippy::too_many_arguments)]\n"); + .raw("#![allow(clippy::too_many_arguments)]\n") + .raw("#![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); @@ -2047,7 +2048,7 @@ impl GenerationScope { &mut deser_code.content, ); return_if_deserialized - .line(format!("Ok(({})) => return Ok({}),", + .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(),") From 9f6e20a243680328098a295ad7ca4f2b64801ceb Mon Sep 17 00:00:00 2001 From: SimonIT Date: Fri, 3 Mar 2023 13:40:46 +0100 Subject: [PATCH 03/25] Begin adapting cbor_event no_std changes and replace std with core --- src/generation.rs | 32 ++++++----- static/error.rs | 39 ++++++++----- static/ordered_hash_map.rs | 21 +++++-- static/ordered_hash_map_schemars.rs | 17 ++++-- static/serialization.rs | 15 +++-- static/serialization_non_force_canonical.rs | 8 +-- static/serialization_non_preserve.rs | 12 ++-- static/serialization_preserve.rs | 26 +++++---- .../serialization_preserve_force_canonical.rs | 56 ++++++++++++------- ...ialization_preserve_non_force_canonical.rs | 41 ++++++++------ tests/external_rust_defs | 6 +- ...rnal_rust_defs_compiles_with_json_preserve | 8 +-- tests/external_rust_raw_bytes_def | 4 +- 13 files changed, 173 insertions(+), 112 deletions(-) diff --git a/src/generation.rs b/src/generation.rs index 8fc7926..bcb6cdf 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -716,7 +716,10 @@ impl GenerationScope { } // declare modules (root lib specific) - self.rust_lib().raw("pub mod error;"); + self.rust_lib() + .raw("pub mod error;") + .raw("extern crate alloc;") + .push_import("alloc::string", "String", None); if CLI_ARGS.preserve_encodings { self.rust_lib() .raw("pub mod ordered_hash_map;") @@ -744,7 +747,7 @@ 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); // in case we store these in enums we're just going to dump them in everywhere if CLI_ARGS.preserve_encodings { @@ -759,7 +762,7 @@ 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("crate::serialization", "LenEncoding", None) .push_import("crate::serialization", "StringEncoding", None); } @@ -829,7 +832,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_ARGS.preserve_encodings { if scope == "lib" { content.push_import("ordered_hash_map", "OrderedHashMap", None); @@ -849,10 +852,9 @@ impl GenerationScope { }; 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", "fmt", None) + .push_import("alloc::string", "String", None) + .push_import("alloc::vec", "Vec", None) .push_import("cbor_event::de", "Deserializer", None) .push_import("cbor_event::se", "Serializer", None) .push_import(error_scope, "*", None); @@ -902,7 +904,7 @@ impl GenerationScope { None, ); } else { - content.push_import("std::collections", "BTreeMap", None); + content.push_import("alloc::collections", "BTreeMap", None); } } } @@ -5542,7 +5544,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); @@ -5903,7 +5905,7 @@ fn generate_enum( Some(&ctor_exprs), ); 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.deser_code.content); deser_body.push_block(variant_deser); @@ -5947,9 +5949,9 @@ fn generate_enum( fn make_serialization_function(name: &str) -> codegen::Function { let mut f = codegen::Function::new(name); f.generic("'se, W: Write") - .ret("cbor_event::Result<&'se mut Serializer>") + .ret("cbor_event::Result<&'se mut Serializer>") .arg_ref_self() - .arg("serializer", "&'se mut Serializer"); + .arg("serializer", "&'se mut Serializer"); if CLI_ARGS.preserve_encodings && CLI_ARGS.canonical_form { f.arg("force_canonical", "bool"); } @@ -5970,7 +5972,7 @@ 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"); + .arg("raw", "&mut Deserializer"); f } @@ -6554,7 +6556,7 @@ fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes) { .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<'_>") diff --git a/static/error.rs b/static/error.rs index 12aa6a0..f81a49c 100644 --- a/static/error.rs +++ b/static/error.rs @@ -1,5 +1,7 @@ +use alloc::boxed::Box; +use alloc::format; +use alloc::string::String; use cbor_event::{self, de::Deserializer}; -use std::io::{BufRead, Seek}; #[derive(Debug)] pub enum Key { @@ -8,7 +10,7 @@ pub enum Key { Float(f64), } -impl std::fmt::Display for Key { +impl core::fmt::Display for Key { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Key::Str(x) => write!(f, "\"{}\"", x), @@ -26,7 +28,7 @@ pub enum DeserializeFailure { DuplicateKey(Key), EndingBreakMissing, ExpectedNull, - FixedValueMismatch{ + FixedValueMismatch { found: Key, expected: Key, }, @@ -34,12 +36,12 @@ pub enum DeserializeFailure { InvalidStructure(Box), MandatoryFieldMissing(Key), NoVariantMatched, - RangeCheck{ + RangeCheck { found: usize, min: Option, max: Option, }, - TagMismatch{ + TagMismatch { found: u64, expected: u64, }, @@ -70,14 +72,17 @@ impl DeserializeError { } } -impl std::fmt::Display for DeserializeError { +impl core::fmt::Display for DeserializeError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match &self.location { Some(loc) => write!(f, "Deserialization failed in {} because: ", loc), 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)?; @@ -85,25 +90,33 @@ impl std::fmt::Display for 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::RangeCheck{ found, min, max } => match (min, max) { + DeserializeFailure::RangeCheck { found, min, max } => match (min, max) { (Some(min), Some(max)) => write!(f, "{} not in range {} - {}", found, min, max), (Some(min), None) => write!(f, "{} not at least {}", found, min), (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) + } } } } diff --git a/static/ordered_hash_map.rs b/static/ordered_hash_map.rs index d66bb43..cf373d3 100644 --- a/static/ordered_hash_map.rs +++ b/static/ordered_hash_map.rs @@ -1,10 +1,14 @@ 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 +16,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_schemars.rs b/static/ordered_hash_map_schemars.rs index d315bbe..93fa9eb 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) + core::collections::BTreeMap::::json_schema(gen) + } + fn is_referenceable() -> bool { + std::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 391643a..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 { @@ -15,4 +15,4 @@ impl ToCBORBytes for T { self.serialize(&mut buf).unwrap(); buf.finalize() } -} \ No newline at end of file +} 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 a0fa36e..a89df61 100644 --- a/static/serialization_preserve.rs +++ b/static/serialization_preserve.rs @@ -22,7 +22,7 @@ impl CBORReadLen { } else { Ok(()) } - }, + } cbor_event::LenSz::Indefinite => Ok(()), } } @@ -35,18 +35,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] @@ -76,11 +78,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, } } @@ -106,4 +110,4 @@ impl From for StringEncoding { cbor_event::StringLenSz::Indefinite(lens) => Self::Indefinite(lens), } } -} \ No newline at end of file +} diff --git a/static/serialization_preserve_force_canonical.rs b/static/serialization_preserve_force_canonical.rs index 465c9c0..9baf6cb 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, W: Write + Sized>( + &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()), } } @@ -68,15 +82,15 @@ pub trait Serialize { fn serialize<'a, W: Write + Sized>( &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>( &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..c2ea12b 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, W: Write + Sized>( + &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/external_rust_defs b/tests/external_rust_defs index 78d4073..c797ea3 100644 --- a/tests/external_rust_defs +++ b/tests/external_rust_defs @@ -18,8 +18,8 @@ impl ExternalFoo { impl cbor_event::se::Serialize for ExternalFoo { fn serialize<'se, W: std::io::Write>( &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..ed2b009 100644 --- a/tests/external_rust_defs_compiles_with_json_preserve +++ b/tests/external_rust_defs_compiles_with_json_preserve @@ -19,10 +19,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 +32,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 965ec13..d6e8f31 100644 --- a/tests/external_rust_raw_bytes_def +++ b/tests/external_rust_raw_bytes_def @@ -11,13 +11,13 @@ pub enum CryptoError { WrongSize, } -impl std::fmt::Display for CryptoError { +impl core::fmt::Display for CryptoError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "CryptoError::WrongSize") } } -impl std::error::Error for CryptoError {} +impl core::error::Error for CryptoError {} #[derive(Clone, Debug)] pub struct PubKey([u8; 32]); From 4d8af30102b45c6421d433cdfd6ca111808ffa15 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Fri, 3 Mar 2023 14:35:32 +0100 Subject: [PATCH 04/25] Re-add accidentally removed | --- src/generation.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/generation.rs b/src/generation.rs index bcb6cdf..e24b2f6 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -5544,7 +5544,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); From aca97183dff6bb6229fc4abb9557577cf215198b Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sat, 4 Mar 2023 14:17:44 +0100 Subject: [PATCH 05/25] More std to core transformation --- src/generation.rs | 11 +++---- static/error.rs | 6 ++-- static/ordered_hash_map_json.rs | 30 ++++++++++++------- .../serialization_preserve_force_canonical.rs | 6 ++-- ...ialization_preserve_non_force_canonical.rs | 2 +- 5 files changed, 33 insertions(+), 22 deletions(-) diff --git a/src/generation.rs b/src/generation.rs index e24b2f6..ae91dee 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -700,7 +700,8 @@ impl GenerationScope { // rust self.rust_lib() .raw("#![allow(clippy::too_many_arguments)]\n") - .raw("#![no_std]\n"); + .raw("#![no_std]\n") + .raw("#![feature(error_in_core)]\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); @@ -6559,13 +6560,13 @@ fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes) { .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") @@ -6586,7 +6587,7 @@ fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes) { } 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/error.rs b/static/error.rs index f81a49c..0511729 100644 --- a/static/error.rs +++ b/static/error.rs @@ -11,7 +11,7 @@ pub enum Key { } impl core::fmt::Display for Key { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + 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), @@ -33,7 +33,7 @@ pub enum DeserializeFailure { expected: Key, }, /// Invalid internal structure imposed on top of the CBOR format - InvalidStructure(Box), + InvalidStructure(Box), MandatoryFieldMissing(Key), NoVariantMatched, RangeCheck { @@ -73,7 +73,7 @@ impl DeserializeError { } impl core::fmt::Display for DeserializeError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match &self.location { Some(loc) => write!(f, "Deserialization failed in {} because: ", loc), None => write!(f, "Deserialization: "), diff --git a/static/ordered_hash_map_json.rs b/static/ordered_hash_map_json.rs index b519287..020d3af 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/serialization_preserve_force_canonical.rs b/static/serialization_preserve_force_canonical.rs index 9baf6cb..2649bd9 100644 --- a/static/serialization_preserve_force_canonical.rs +++ b/static/serialization_preserve_force_canonical.rs @@ -35,7 +35,7 @@ impl LenEncoding { } } - pub fn end<'a, W: Write + Sized>( + pub fn end<'a>( &self, serializer: &'a mut Serializer, force_canonical: bool, @@ -80,7 +80,7 @@ pub trait Serialize { buf.finalize() } - fn serialize<'a, W: Write + Sized>( + fn serialize<'a>( &self, serializer: &'a mut Serializer, force_canonical: bool, @@ -88,7 +88,7 @@ pub trait Serialize { } pub trait SerializeEmbeddedGroup { - fn serialize_as_embedded_group<'a, W: Write + Sized>( + fn serialize_as_embedded_group<'a>( &self, serializer: &'a mut Serializer, force_canonical: bool, diff --git a/static/serialization_preserve_non_force_canonical.rs b/static/serialization_preserve_non_force_canonical.rs index c2ea12b..370645b 100644 --- a/static/serialization_preserve_non_force_canonical.rs +++ b/static/serialization_preserve_non_force_canonical.rs @@ -27,7 +27,7 @@ impl LenEncoding { } } - pub fn end<'a, W: Write + Sized>( + pub fn end<'a>( &self, serializer: &'a mut Serializer, ) -> cbor_event::Result<&'a mut Serializer> { From 08fafe2604ebc744d468eadeb153a2bc3c155c44 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sat, 4 Mar 2023 16:41:10 +0100 Subject: [PATCH 06/25] More adaption --- example/serialization_unit_tests.rs | 43 +- src/generation.rs | 15 +- tests/canonical/tests.rs | 757 +++++++++++++++++----------- tests/core/tests.rs | 65 ++- tests/deser_test | 4 +- tests/external_rust_defs | 2 +- tests/external_rust_raw_bytes_def | 4 +- tests/preserve-encodings/tests.rs | 721 ++++++++++++++++---------- tests/raw-bytes/tests.rs | 6 +- tests/rust-wasm-split/tests.rs | 23 +- 10 files changed, 1051 insertions(+), 589 deletions(-) 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 ae91dee..99cccc4 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -701,7 +701,8 @@ impl GenerationScope { self.rust_lib() .raw("#![allow(clippy::too_many_arguments)]\n") .raw("#![no_std]\n") - .raw("#![feature(error_in_core)]\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); @@ -720,7 +721,10 @@ impl GenerationScope { self.rust_lib() .raw("pub mod error;") .raw("extern crate alloc;") - .push_import("alloc::string", "String", None); + .push_import("alloc::borrow", "ToOwned", None) + .push_import("alloc::string", "String", None) + .push_import("alloc", "vec", None) + .push_import("alloc::vec", "Vec", None); if CLI_ARGS.preserve_encodings { self.rust_lib() .raw("pub mod ordered_hash_map;") @@ -749,7 +753,9 @@ impl GenerationScope { // needed if there's any params that can fail content .push_import("core::convert", "TryFrom", None) - .push_import("crate::error", "*", None); + .push_import("crate::error", "*", None) + .push_import("alloc::string", "String", None) + .push_import("alloc::vec", "Vec", None); // in case we store these in enums we're just going to dump them in everywhere if CLI_ARGS.preserve_encodings { content @@ -853,6 +859,7 @@ impl GenerationScope { }; content .push_import("super", "*", None) + .push_import("alloc::borrow", "ToOwned", None) .push_import("alloc", "fmt", None) .push_import("alloc::string", "String", None) .push_import("alloc::vec", "Vec", None) @@ -2600,7 +2607,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( diff --git a/tests/canonical/tests.rs b/tests/canonical/tests.rs index 26c9575..326092d 100644 --- a/tests/canonical/tests.rs +++ b/tests/canonical/tests.rs @@ -1,42 +1,54 @@ #[cfg(test)] mod tests { use super::*; - use cbor_event::{de::Deserializer, Sz, StringLenSz}; + use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; 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(); + 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(); + 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()); + 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 +59,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 +108,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 +171,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); 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,55 +248,72 @@ 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], vec![BREAK], - ].into_iter().flatten().clone().collect::>(); + ] + .into_iter() + .flatten() + .clone() + .collect::>(); print_cbor_types("non_canonical_bytes", &non_canonical_bytes); 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::>(); + 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); assert_eq!(table.to_canonical_cbor_bytes(), canonical_bytes); deser_test_canonical(&table); @@ -248,86 +324,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 +445,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 +513,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/core/tests.rs b/tests/core/tests.rs index 419ef6a..304652c 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -6,10 +6,10 @@ mod tests { 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); + 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); } @@ -28,7 +28,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] @@ -38,7 +41,11 @@ mod tests { #[test] fn bar() { - deser_test(&Bar::new(Foo::new(436, String::from("jfkdf"), vec![6, 4]), None, 3.3)); + deser_test(&Bar::new( + Foo::new(436, String::from("jfkdf"), vec![6, 4]), + None, + 3.3, + )); } #[test] @@ -54,12 +61,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 = core::collections::BTreeMap::new(); tab.insert(String::from("43266556"), String::from("2k2j343")); tab.insert(String::from("213543254546565"), String::from("!!fjdj")); let mut foos = vec![ @@ -79,7 +89,7 @@ mod tests { fn type_choice_hello_world() { deser_test(&TypeChoice::Helloworld); } - + #[test] fn type_choice_uint() { deser_test(&TypeChoice::U64(53435364)); @@ -117,7 +127,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] @@ -138,9 +151,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); } @@ -160,7 +193,9 @@ 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()]; // these don't have @no_alias @@ -179,7 +214,11 @@ mod tests { #[test] fn externs() { - let externs = Externs::new(ExternalFoo::new(436, String::from("jfkdsjfd"), vec![1, 1, 1])); + let externs = Externs::new(ExternalFoo::new( + 436, + String::from("jfkdsjfd"), + vec![1, 1, 1], + )); deser_test(&externs); } } diff --git a/tests/deser_test b/tests/deser_test index 43d3298..7d8c7dc 100644 --- a/tests/deser_test +++ b/tests/deser_test @@ -67,9 +67,9 @@ fn cbor_bytes_sz(bytes: Vec, sz: cbor_event::StringLenSz) -> Vec { buf.finalize() } -fn print_cbor_types(obj_name: &str, vec: &Vec) { +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 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() { diff --git a/tests/external_rust_defs b/tests/external_rust_defs index c797ea3..a6de353 100644 --- a/tests/external_rust_defs +++ b/tests/external_rust_defs @@ -16,7 +16,7 @@ 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> { diff --git a/tests/external_rust_raw_bytes_def b/tests/external_rust_raw_bytes_def index d6e8f31..afa5f38 100644 --- a/tests/external_rust_raw_bytes_def +++ b/tests/external_rust_raw_bytes_def @@ -12,7 +12,7 @@ pub enum CryptoError { } impl core::fmt::Display for CryptoError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "CryptoError::WrongSize") } } @@ -28,7 +28,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).or(Err(CryptoError::WrongSize)) } } diff --git a/tests/preserve-encodings/tests.rs b/tests/preserve-encodings/tests.rs index 504b2ef..a2d8548 100644 --- a/tests/preserve-encodings/tests.rs +++ b/tests/preserve-encodings/tests.rs @@ -1,13 +1,13 @@ #[cfg(test)] mod tests { use super::*; - use cbor_event::{de::Deserializer, Sz, StringLenSz}; + use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; 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 +50,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 +124,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); 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 +199,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], - ].into_iter().flatten().clone().collect::>(); + 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::>(); 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 +260,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 +275,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 +343,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 +374,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 +471,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() + ); } } } @@ -374,11 +509,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::>(); } } } @@ -394,43 +533,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()); @@ -443,26 +601,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()); } @@ -472,10 +641,34 @@ 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]; + 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); @@ -484,45 +677,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()); } @@ -540,29 +741,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/tests.rs b/tests/raw-bytes/tests.rs index bdc65a3..c2f3088 100644 --- a/tests/raw-bytes/tests.rs +++ b/tests/raw-bytes/tests.rs @@ -6,10 +6,10 @@ mod tests { 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); + 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); } diff --git a/tests/rust-wasm-split/tests.rs b/tests/rust-wasm-split/tests.rs index 102d637..36e8ddd 100644 --- a/tests/rust-wasm-split/tests.rs +++ b/tests/rust-wasm-split/tests.rs @@ -5,9 +5,9 @@ mod tests { use serialization::Deserialize; 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 +28,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 +41,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 +56,7 @@ mod tests { fn type_choice_hello_world() { deser_test(&TypeChoice::Helloworld); } - + #[test] fn type_choice_uint() { deser_test(&TypeChoice::U64(53435364)); @@ -83,6 +89,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"), + ))); } } From 13f0bc07144111a549a2a382da79cf49f9a15b43 Mon Sep 17 00:00:00 2001 From: Connectety-T Date: Sat, 4 Mar 2023 17:08:09 +0100 Subject: [PATCH 07/25] remove blocking generic --- src/generation.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/generation.rs b/src/generation.rs index 99cccc4..28097f4 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -5956,7 +5956,7 @@ fn generate_enum( fn make_serialization_function(name: &str) -> codegen::Function { let mut f = codegen::Function::new(name); - f.generic("'se, W: Write") + f.generic("'se") .ret("cbor_event::Result<&'se mut Serializer>") .arg_ref_self() .arg("serializer", "&'se mut Serializer"); @@ -5978,8 +5978,7 @@ fn make_serialization_impl(name: &str) -> codegen::Impl { fn make_deserialization_function(name: &str) -> codegen::Function { let mut f = codegen::Function::new(name); - f.generic("R: BufRead + Seek") - .ret("Result") + f.ret("Result") .arg("raw", "&mut Deserializer"); f } From a0c2db71a999e3f8c188447b73d7c0a63df20f35 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sat, 4 Mar 2023 17:49:43 +0100 Subject: [PATCH 08/25] Remove lib from cargo toml to not have to specify a global memory allocator and panic handler --- static/Cargo_rust.toml | 3 --- 1 file changed, 3 deletions(-) diff --git a/static/Cargo_rust.toml b/static/Cargo_rust.toml index 4fc830a..ee187a9 100644 --- a/static/Cargo_rust.toml +++ b/static/Cargo_rust.toml @@ -3,8 +3,5 @@ name = "cddl-lib" version = "0.1.0" edition = "2018" -[lib] -crate-type = ["cdylib", "rlib"] - [dependencies] cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } From 8380d6d22c972ae38885952ddb8a08b995fa3e1e Mon Sep 17 00:00:00 2001 From: SimonIT Date: Wed, 8 Mar 2023 20:50:10 +0100 Subject: [PATCH 09/25] It's alloc::collections not core --- static/ordered_hash_map_json.rs | 4 ++-- static/ordered_hash_map_schemars.rs | 2 +- tests/core/tests.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/static/ordered_hash_map_json.rs b/static/ordered_hash_map_json.rs index 020d3af..c2ca306 100644 --- a/static/ordered_hash_map_json.rs +++ b/static/ordered_hash_map_json.rs @@ -7,7 +7,7 @@ where where S: serde::Serializer, { - let map = self.iter().collect::>(); + let map = self.iter().collect::>(); map.serialize(serializer) } } @@ -21,7 +21,7 @@ where where D: serde::de::Deserializer<'de>, { - let map = as serde::de::Deserialize>::deserialize( + 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 93fa9eb..9bd66e4 100644 --- a/static/ordered_hash_map_schemars.rs +++ b/static/ordered_hash_map_schemars.rs @@ -7,7 +7,7 @@ where format!("OrderedHashMap<{}, {}>", K::schema_name(), V::schema_name()) } fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema { - core::collections::BTreeMap::::json_schema(gen) + alloc::collections::BTreeMap::::json_schema(gen) } fn is_referenceable() -> bool { std::collections::BTreeMap::::is_referenceable() diff --git a/tests/core/tests.rs b/tests/core/tests.rs index 304652c..157a299 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -69,7 +69,7 @@ mod tests { #[test] fn table_arr_members() { - let mut tab = core::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![ From a39aea8d558174df3efb9ff359a83a59f5c11217 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Wed, 8 Mar 2023 22:11:47 +0100 Subject: [PATCH 10/25] Add Vec import to cbor_encondings --- src/generation.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/generation.rs b/src/generation.rs index 28097f4..de0a792 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -770,6 +770,7 @@ impl GenerationScope { for content in self.cbor_encodings_scopes.values_mut() { content .push_import("alloc::collections", "BTreeMap", None) + .push_import("alloc::vec", "Vec", None) .push_import("crate::serialization", "LenEncoding", None) .push_import("crate::serialization", "StringEncoding", None); } From 78a4a4b0fd1e83e39b7cad321037ac53f4de6582 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Wed, 8 Mar 2023 22:16:22 +0100 Subject: [PATCH 11/25] Convert std min to core min --- tests/preserve-encodings/tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/preserve-encodings/tests.rs b/tests/preserve-encodings/tests.rs index a2d8548..be0f27c 100644 --- a/tests/preserve-encodings/tests.rs +++ b/tests/preserve-encodings/tests.rs @@ -640,7 +640,7 @@ mod tests { #[test] fn signed_ints() { - use std::cmp::min; + use core::cmp::min; let umins = [ 0i128, u8::MIN as i128, From 141dc6e12f44681c0c62570b9a430d21330ee866 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Tue, 14 Mar 2023 00:17:32 +0100 Subject: [PATCH 12/25] Move print_cbor_types to tests --- tests/core/tests.rs | 91 +++++++++++++++++++++++++++++++++++++++++++++ tests/deser_test | 91 --------------------------------------------- 2 files changed, 91 insertions(+), 91 deletions(-) diff --git a/tests/core/tests.rs b/tests/core/tests.rs index 157a299..38cbdf9 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -4,6 +4,97 @@ mod tests { use cbor_event::de::Deserializer; use serialization::Deserialize; + 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); diff --git a/tests/deser_test b/tests/deser_test index 7d8c7dc..3fd4ff7 100644 --- a/tests/deser_test +++ b/tests/deser_test @@ -66,94 +66,3 @@ fn cbor_bytes_sz(bytes: Vec, sz: cbor_event::StringLenSz) -> Vec { buf.write_bytes_sz(bytes, sz).unwrap(); buf.finalize() } - -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!("}}"); -} From ac50a902bbb3e99fc9e506eeb75093e852a7d586 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Tue, 14 Mar 2023 00:18:10 +0100 Subject: [PATCH 13/25] Add more alloc imports --- src/generation.rs | 3 ++- tests/comment-dsl/tests.rs | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/generation.rs b/src/generation.rs index de0a792..09a5be1 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -861,6 +861,7 @@ impl GenerationScope { content .push_import("super", "*", 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::vec", "Vec", None) @@ -1599,7 +1600,7 @@ impl GenerationScope { let mut key_order_sort_match = codegen::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); diff --git a/tests/comment-dsl/tests.rs b/tests/comment-dsl/tests.rs index 20f8640..13ec314 100644 --- a/tests/comment-dsl/tests.rs +++ b/tests/comment-dsl/tests.rs @@ -1,6 +1,7 @@ #[cfg(test)] mod tests { use super::*; + use alloc::string::ToString; #[test] fn group_type() { From 8fb4c9c09a1319ddf49340da7f17a417ab71becd Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sun, 19 Mar 2023 22:13:30 +0100 Subject: [PATCH 14/25] Use to_string for Error Result --- Cargo.lock | 2 +- src/generation.rs | 19 +++++++++++-------- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4200360..6f2e2a3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -110,7 +110,7 @@ checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535" [[package]] name = "cbor_event" version = "2.4.0" -source = "git+https://github.com/SimonIT/cbor_event?branch=no_std#c3c36ab13d3efe3c960bae5ff7b65cb1d7032aac" +source = "git+https://github.com/SimonIT/cbor_event?branch=no_std#78c0ba4eff9a0d20443e48431ac886a802d9b6b8" [[package]] name = "cc" diff --git a/src/generation.rs b/src/generation.rs index 09a5be1..8f10b12 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -864,6 +864,7 @@ impl GenerationScope { .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) @@ -2042,7 +2043,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().seek(SeekFrom::Current(0)).unwrap();"); let mut variant_final_exprs = config.final_exprs.clone(); if CLI_ARGS.preserve_encodings { for enc_var in @@ -2060,10 +2060,15 @@ impl GenerationScope { &mut deser_code.content, ); 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(),") + .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); } @@ -5643,7 +5648,6 @@ fn generate_enum( ); deser_impl }; - deser_body.line("let initial_position = raw.as_mut_ref().seek(SeekFrom::Current(0)).unwrap();"); for variant in variants.iter() { let enum_gen_info = EnumVariantInRust::new(types, variant, rep); let variant_var_name = variant.name_as_var(); @@ -5925,8 +5929,7 @@ fn generate_enum( return_if_deserialized } }; - return_if_deserialized - .line("Err(_) => raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap(),"); + return_if_deserialized.line("Err(_) => raw.to_string(),"); return_if_deserialized.after(";"); deser_body.push_block(return_if_deserialized); } From 7cb437e2e4878d895891bc0fe3b8094679453a1e Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sun, 19 Mar 2023 23:34:58 +0100 Subject: [PATCH 15/25] Fix hash_map and wasm imports --- src/generation.rs | 2 +- static/ordered_hash_map.rs | 2 ++ static/ordered_hash_map_schemars.rs | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/generation.rs b/src/generation.rs index 8f10b12..2c9ec67 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -915,7 +915,7 @@ impl GenerationScope { None, ); } else { - content.push_import("alloc::collections", "BTreeMap", None); + content.push_import("std::collections", "BTreeMap", None); } } } diff --git a/static/ordered_hash_map.rs b/static/ordered_hash_map.rs index cf373d3..087b914 100644 --- a/static/ordered_hash_map.rs +++ b/static/ordered_hash_map.rs @@ -1,3 +1,5 @@ +use alloc::format; +use alloc::string::String; use core::hash::Hash; #[derive(Clone, Debug, Default, Hash, Ord, Eq, PartialEq, PartialOrd)] diff --git a/static/ordered_hash_map_schemars.rs b/static/ordered_hash_map_schemars.rs index 9bd66e4..74ee0de 100644 --- a/static/ordered_hash_map_schemars.rs +++ b/static/ordered_hash_map_schemars.rs @@ -10,6 +10,6 @@ where alloc::collections::BTreeMap::::json_schema(gen) } fn is_referenceable() -> bool { - std::collections::BTreeMap::::is_referenceable() + alloc::collections::BTreeMap::::is_referenceable() } } From 269f47c7ebd7007f88163f8e60df9a6f40cfbb63 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Thu, 23 Mar 2023 22:13:03 +0100 Subject: [PATCH 16/25] Fix some test compilation with print_cbor_types --- src/generation.rs | 1 + tests/canonical/tests.rs | 110 +++++++++++++++++++++++++++--- tests/core/tests.rs | 1 + tests/preserve-encodings/tests.rs | 96 +++++++++++++++++++++++++- tests/raw-bytes/tests.rs | 92 +++++++++++++++++++++++++ tests/rust-wasm-split/tests.rs | 92 +++++++++++++++++++++++++ 6 files changed, 381 insertions(+), 11 deletions(-) diff --git a/src/generation.rs b/src/generation.rs index 2c9ec67..2777661 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -721,6 +721,7 @@ impl GenerationScope { 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::string", "String", None) .push_import("alloc", "vec", None) diff --git a/tests/canonical/tests.rs b/tests/canonical/tests.rs index 326092d..682d14b 100644 --- a/tests/canonical/tests.rs +++ b/tests/canonical/tests.rs @@ -3,19 +3,111 @@ mod tests { use super::*; use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; + use std::{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()); + 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()); + 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()); + 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()); + print_cbor_types("deser", deser.to_canonical_cbor_bytes()); assert_eq!( orig.to_canonical_cbor_bytes(), deser.to_canonical_cbor_bytes() @@ -223,16 +315,16 @@ mod tests { 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); let irregular_bar = Bar::from_cbor_bytes(&irregular_encoding).unwrap(); print_cbor_types( "irregular_bar.to_cbor_bytes()", - &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(), + irregular_bar.to_canonical_cbor_bytes(), ); assert_eq!( irregular_bar.to_canonical_cbor_bytes(), @@ -286,7 +378,7 @@ mod tests { .flatten() .clone() .collect::>(); - print_cbor_types("non_canonical_bytes", &non_canonical_bytes); + print_cbor_types("non_canonical_bytes", non_canonical_bytes); let table = TableArrMembers::from_cbor_bytes(&non_canonical_bytes).unwrap(); assert_eq!(table.to_cbor_bytes(), non_canonical_bytes); let canonical_bytes = vec![ @@ -314,7 +406,7 @@ mod tests { .flatten() .clone() .collect::>(); - print_cbor_types("canonical_bytes", &canonical_bytes); + print_cbor_types("canonical_bytes", canonical_bytes); assert_eq!(table.to_canonical_cbor_bytes(), canonical_bytes); deser_test_canonical(&table); deser_test_orig(&table); diff --git a/tests/core/tests.rs b/tests/core/tests.rs index 38cbdf9..ad4c100 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -3,6 +3,7 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; + use std::{print, println}; fn print_cbor_types(obj_name: &str, vec: Vec) { use cbor_event::Type; diff --git a/tests/preserve-encodings/tests.rs b/tests/preserve-encodings/tests.rs index be0f27c..3287227 100644 --- a/tests/preserve-encodings/tests.rs +++ b/tests/preserve-encodings/tests.rs @@ -3,6 +3,98 @@ mod tests { use super::*; use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; + use std::{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()); @@ -172,11 +264,11 @@ mod tests { 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); let irregular_bar = Bar::from_cbor_bytes(&irregular_encoding).unwrap(); print_cbor_types( "irregular_bar.to_cbor_bytes()", - &irregular_bar.to_cbor_bytes(), + irregular_bar.to_cbor_bytes(), ); assert_eq!(irregular_bar.to_cbor_bytes(), irregular_encoding); } diff --git a/tests/raw-bytes/tests.rs b/tests/raw-bytes/tests.rs index c2f3088..c966af6 100644 --- a/tests/raw-bytes/tests.rs +++ b/tests/raw-bytes/tests.rs @@ -3,6 +3,98 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; + use std::{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(); diff --git a/tests/rust-wasm-split/tests.rs b/tests/rust-wasm-split/tests.rs index 36e8ddd..0d71ace 100644 --- a/tests/rust-wasm-split/tests.rs +++ b/tests/rust-wasm-split/tests.rs @@ -3,6 +3,98 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; + use std::{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()); From 2bf61d38435d2a2a5a418cb973eaa3855d66a7d9 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Wed, 29 Mar 2023 22:39:56 +0200 Subject: [PATCH 17/25] Introduce feature std for JsonSchema, Derivative --- Cargo.lock | 2 +- Cargo.toml | 4 +-- src/generation.rs | 30 ++++++++++++++++--- static/Cargo_rust.toml | 3 ++ ...rnal_rust_defs_compiles_with_json_preserve | 3 +- 5 files changed, 34 insertions(+), 8 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6f2e2a3..20bb595 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -294,7 +294,7 @@ dependencies = [ [[package]] name = "codegen" version = "0.2.0" -source = "git+https://github.com/dcSpark/codegen?branch=master#a31b2eff7adfd65dfdb10d6a4d7a83bd2f5d6010" +source = "git+https://github.com/SimonIT/codegen?branch=cfg_attr#70d7b3888be76fdd649c63456f842463b181beea" dependencies = [ "indexmap", "quote", diff --git a/Cargo.toml b/Cargo.toml index d7ac228..701ab77 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,10 +12,10 @@ which-rustfmt = ["which"] cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } cddl = "0.9.1" clap = { version = "4.1.4", features = ["derive"] } -codegen = { git = "https://github.com/dcSpark/codegen", branch = "master" } +codegen = { git = "https://github.com/SimonIT/codegen", branch = "cfg_attr" } either = "1.8.1" once_cell = "1.17.0" nom = "7.1.1" which = { version = "4.4.0", optional = true, default-features = false } syn = "1.0.107" -quote = "1.0.23" \ No newline at end of file +quote = "1.0.23" diff --git a/src/generation.rs b/src/generation.rs index 2777661..e83379f 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -2858,7 +2858,7 @@ fn canonical_param() -> &'static str { fn encoding_var_macros(used_in_key: bool) -> String { let mut ret = if used_in_key { format!( - "#[derivative({})]\n", + "#[cfg_attr(feature = \"std\", derivative({}))]\n", key_derives(true) .iter() .map(|derive| format!("{derive}=\"ignore\"")) @@ -3044,18 +3044,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( @@ -6388,15 +6398,18 @@ fn add_struct_derives(data_type: &mut T, used_in_key: bool, is_enum .derive("serde::Deserialize") .derive("serde::Serialize"); } + let mut std_derives = vec![]; + let mut std_predicates = vec![]; if CLI_ARGS.json_schema_export { - data_type.derive("schemars::JsonSchema"); + std_derives.push("schemars::JsonSchema".to_string()); } if used_in_key { if CLI_ARGS.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) .iter() .map(|tr| match *tr { @@ -6414,6 +6427,15 @@ fn add_struct_derives(data_type: &mut T, used_in_key: bool, is_enum } } } + if !std_derives.is_empty() { + std_predicates.insert(0, format!("derive({})", std_derives.join(", ")).to_string()); + } + if !std_predicates.is_empty() { + data_type.cfg_attr(&*format!( + "feature = \"std\", {}", + std_predicates.join(", ") + )); + } } fn generate_int(gen_scope: &mut GenerationScope, types: &IntermediateTypes) { diff --git a/static/Cargo_rust.toml b/static/Cargo_rust.toml index ee187a9..9f25604 100644 --- a/static/Cargo_rust.toml +++ b/static/Cargo_rust.toml @@ -3,5 +3,8 @@ name = "cddl-lib" version = "0.1.0" edition = "2018" +[features] +std = [] + [dependencies] cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } diff --git a/tests/external_rust_defs_compiles_with_json_preserve b/tests/external_rust_defs_compiles_with_json_preserve index ed2b009..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, From e2d79e3b07d8745d99897ef767ad93e458ca3e9e Mon Sep 17 00:00:00 2001 From: SimonIT Date: Wed, 29 Mar 2023 22:42:57 +0200 Subject: [PATCH 18/25] Fix deser_test --- tests/core/tests.rs | 2 +- tests/raw-bytes/tests.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/core/tests.rs b/tests/core/tests.rs index ad4c100..749d209 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -103,7 +103,7 @@ mod tests { let deser = T::deserialize(&mut deserializer).unwrap(); 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); + assert_eq!(deserializer.as_ref(), &orig_bytes); } #[test] diff --git a/tests/raw-bytes/tests.rs b/tests/raw-bytes/tests.rs index c966af6..8188f0f 100644 --- a/tests/raw-bytes/tests.rs +++ b/tests/raw-bytes/tests.rs @@ -103,7 +103,7 @@ mod tests { let deser = T::deserialize(&mut deserializer).unwrap(); 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); + assert_eq!(deserializer.as_ref(), &orig_bytes); } #[test] From 7db794aa5bfd07d88740a599ed7e16e0acf43881 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Thu, 30 Mar 2023 23:04:25 +0200 Subject: [PATCH 19/25] Fix some borrowing in tests with cloning --- tests/canonical/tests.rs | 6 +++--- tests/core/tests.rs | 3 +-- tests/preserve-encodings/tests.rs | 2 +- tests/raw-bytes/tests.rs | 3 +-- 4 files changed, 6 insertions(+), 8 deletions(-) diff --git a/tests/canonical/tests.rs b/tests/canonical/tests.rs index 682d14b..bfddb97 100644 --- a/tests/canonical/tests.rs +++ b/tests/canonical/tests.rs @@ -315,7 +315,7 @@ mod tests { 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()", @@ -378,7 +378,7 @@ mod tests { .flatten() .clone() .collect::>(); - print_cbor_types("non_canonical_bytes", non_canonical_bytes); + 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![ @@ -406,7 +406,7 @@ mod tests { .flatten() .clone() .collect::>(); - print_cbor_types("canonical_bytes", canonical_bytes); + 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); diff --git a/tests/core/tests.rs b/tests/core/tests.rs index 749d209..aa15035 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -98,12 +98,11 @@ mod tests { fn deser_test(orig: &T) { let orig_bytes = orig.to_cbor_bytes(); - print_cbor_types("orig", orig_bytes); + 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()); assert_eq!(orig.to_cbor_bytes(), deser.to_cbor_bytes()); - assert_eq!(deserializer.as_ref(), &orig_bytes); } #[test] diff --git a/tests/preserve-encodings/tests.rs b/tests/preserve-encodings/tests.rs index 3287227..f8bb826 100644 --- a/tests/preserve-encodings/tests.rs +++ b/tests/preserve-encodings/tests.rs @@ -264,7 +264,7 @@ mod tests { 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()", diff --git a/tests/raw-bytes/tests.rs b/tests/raw-bytes/tests.rs index 8188f0f..b27e187 100644 --- a/tests/raw-bytes/tests.rs +++ b/tests/raw-bytes/tests.rs @@ -98,12 +98,11 @@ mod tests { fn deser_test(orig: &T) { let orig_bytes = orig.to_cbor_bytes(); - print_cbor_types("orig", orig_bytes); + 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()); assert_eq!(orig.to_cbor_bytes(), deser.to_cbor_bytes()); - assert_eq!(deserializer.as_ref(), &orig_bytes); } #[test] From 4aee0c1d2060d1f69f15d8d96a4e0f5889b5d01d Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sun, 2 Apr 2023 16:07:43 +0200 Subject: [PATCH 20/25] Use cfg_attr branch of codegen --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 54b8a3c..5a7f5ba 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,7 +12,7 @@ which-rustfmt = ["which"] cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } cddl = "0.9.1" clap = { version = "4.1.8", features = ["derive"] } -codegen = { git = "https://github.com/SimonIT/codegen", branch = "master" } +codegen = { git = "https://github.com/SimonIT/codegen", branch = "cfg_attr" } either = "1.8.1" once_cell = "1.17.1" nom = "7.1.1" From 1e2ce8f609cef33e9d525e9af3f3d7d38bfec998 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sat, 22 Apr 2023 11:46:21 +0200 Subject: [PATCH 21/25] Make clippy happy --- src/generation.rs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/generation.rs b/src/generation.rs index e83379f..4336b90 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -6428,13 +6428,10 @@ fn add_struct_derives(data_type: &mut T, used_in_key: bool, is_enum } } if !std_derives.is_empty() { - std_predicates.insert(0, format!("derive({})", std_derives.join(", ")).to_string()); + std_predicates.insert(0, format!("derive({})", std_derives.join(", "))); } if !std_predicates.is_empty() { - data_type.cfg_attr(&*format!( - "feature = \"std\", {}", - std_predicates.join(", ") - )); + data_type.cfg_attr(&format!("feature = \"std\", {}", std_predicates.join(", "))); } } From c2db634f5d3bac1cb5bc6b19322304c0e4a9efd2 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Sun, 23 Apr 2023 13:54:34 +0200 Subject: [PATCH 22/25] Change codegen to dcSpark master --- Cargo.lock | 2 +- Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cc20acc..8a03f57 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -348,7 +348,7 @@ checksum = "8a2dd5a6fe8c6e3502f568a6353e5273bbb15193ad9a89e457b9970798efbea1" [[package]] name = "codegen" version = "0.2.0" -source = "git+https://github.com/SimonIT/codegen?branch=cfg_attr#70d7b3888be76fdd649c63456f842463b181beea" +source = "git+https://github.com/dcSpark/codegen?branch=master#c8273c6ab7af2337b845c7674f36e265890ca3d0" dependencies = [ "indexmap", "quote", diff --git a/Cargo.toml b/Cargo.toml index 9357b64..e04a10f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,7 +12,7 @@ which-rustfmt = ["which"] cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } cddl = "0.9.1" clap = { version = "4.2.2", features = ["derive"] } -codegen = { git = "https://github.com/SimonIT/codegen", branch = "cfg_attr" } +codegen = { git = "https://github.com/dcSpark/codegen", branch = "master" } either = "1.8.1" once_cell = "1.17.1" nom = "7.1.1" From feefef2055000be5b1e5b5303d704768a32a6fe3 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Tue, 25 Apr 2023 22:32:55 +0200 Subject: [PATCH 23/25] Fix test split for core test --- tests/core/tests.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/core/tests.rs b/tests/core/tests.rs index 96abbd3..4bf879d 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -288,7 +288,8 @@ mod 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;")); From 3982e63fec9ecfab8d62aba69172f834ff30fcb6 Mon Sep 17 00:00:00 2001 From: SimonIT Date: Thu, 7 Mar 2024 14:34:25 +0100 Subject: [PATCH 24/25] Adapt changes to no_std --- Cargo.lock | 2 +- Cargo.toml | 2 +- src/generation.rs | 21 +++++++++------------ static/Cargo_rust.toml | 2 +- static/Cargo_wasm.toml | 4 ++-- static/error.rs | 1 + tests/canonical/tests.rs | 2 +- tests/comment-dsl/tests.rs | 1 + tests/core/tests.rs | 2 +- tests/external_json_impls | 2 +- tests/json/tests.rs | 1 + tests/preserve-encodings/tests.rs | 2 +- tests/raw-bytes-preserve/tests.rs | 1 + tests/raw-bytes/tests.rs | 2 +- tests/rust-wasm-split/tests.rs | 2 +- 15 files changed, 24 insertions(+), 23 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a08b25a..88007a2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -180,7 +180,7 @@ checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1" [[package]] name = "cbor_event" version = "2.4.0" -source = "git+https://github.com/SimonIT/cbor_event?branch=no_std#78c0ba4eff9a0d20443e48431ac886a802d9b6b8" +source = "git+https://github.com/primetype/cbor_event#2b6330abe7aa69d230454ea2cadda5015526e681" [[package]] name = "cc" diff --git a/Cargo.toml b/Cargo.toml index a9a0ab5..99f47ad 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ default = ["which-rustfmt"] which-rustfmt = ["which"] [dependencies] -cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } +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" } diff --git a/src/generation.rs b/src/generation.rs index 73b2f6b..7ba7be0 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -773,7 +773,9 @@ impl GenerationScope { .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 { @@ -2398,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( @@ -4750,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)") } @@ -6606,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); @@ -7653,16 +7650,16 @@ 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 .derive("serde::Deserialize") .derive("serde::Serialize"); } - let mut std_derives = vec![]; - let mut std_predicates = vec![]; - if cli.json_schema_export { - std_derives.push("schemars::JsonSchema".to_string()); + if cli.json_schema_export { + std_derives.push("schemars::JsonSchema".to_string()); } } if used_in_key { @@ -7733,7 +7730,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 diff --git a/static/Cargo_rust.toml b/static/Cargo_rust.toml index 9f25604..dcbc914 100644 --- a/static/Cargo_rust.toml +++ b/static/Cargo_rust.toml @@ -7,4 +7,4 @@ edition = "2018" std = [] [dependencies] -cbor_event = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } +cbor_event = { git = "https://github.com/primetype/cbor_event" } diff --git a/static/Cargo_wasm.toml b/static/Cargo_wasm.toml index 63ef223..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 = { git = "https://github.com/SimonIT/cbor_event", branch = "no_std" } -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 7939c1f..0817692 100644 --- a/static/error.rs +++ b/static/error.rs @@ -1,6 +1,7 @@ use alloc::boxed::Box; use alloc::format; use alloc::string::String; +use alloc::vec::Vec; use cbor_event::{self, de::Deserializer}; #[derive(Debug)] diff --git a/tests/canonical/tests.rs b/tests/canonical/tests.rs index bfddb97..75dafd8 100644 --- a/tests/canonical/tests.rs +++ b/tests/canonical/tests.rs @@ -3,7 +3,7 @@ mod tests { use super::*; use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; - use std::{print, println}; + use std::{format, print, println}; fn print_cbor_types(obj_name: &str, vec: Vec) { use cbor_event::Type; diff --git a/tests/comment-dsl/tests.rs b/tests/comment-dsl/tests.rs index 13ec314..86e0dfe 100644 --- a/tests/comment-dsl/tests.rs +++ b/tests/comment-dsl/tests.rs @@ -2,6 +2,7 @@ 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 6dd7ed7..8876075 100644 --- a/tests/core/tests.rs +++ b/tests/core/tests.rs @@ -3,7 +3,7 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; - use std::{print, println}; + use std::{format, print, println}; fn print_cbor_types(obj_name: &str, vec: Vec) { use cbor_event::Type; 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/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 aec9c8e..dbad7d1 100644 --- a/tests/preserve-encodings/tests.rs +++ b/tests/preserve-encodings/tests.rs @@ -3,7 +3,7 @@ mod tests { use super::*; use cbor_event::{de::Deserializer, StringLenSz, Sz}; use serialization::Deserialize; - use std::{print, println}; + use std::{format, print, println}; fn print_cbor_types(obj_name: &str, vec: Vec) { use cbor_event::Type; 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 b27e187..acd8641 100644 --- a/tests/raw-bytes/tests.rs +++ b/tests/raw-bytes/tests.rs @@ -3,7 +3,7 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; - use std::{print, println}; + use std::{format, print, println}; fn print_cbor_types(obj_name: &str, vec: Vec) { use cbor_event::Type; diff --git a/tests/rust-wasm-split/tests.rs b/tests/rust-wasm-split/tests.rs index 0d71ace..880a2fa 100644 --- a/tests/rust-wasm-split/tests.rs +++ b/tests/rust-wasm-split/tests.rs @@ -3,7 +3,7 @@ mod tests { use super::*; use cbor_event::de::Deserializer; use serialization::Deserialize; - use std::{print, println}; + use std::{format, print, println}; fn print_cbor_types(obj_name: &str, vec: Vec) { use cbor_event::Type; From 2cc7fb0db6bdb99d1805c7e9b9f859bf10e9534c Mon Sep 17 00:00:00 2001 From: SimonIT Date: Thu, 7 Mar 2024 14:41:50 +0100 Subject: [PATCH 25/25] Clippy --- src/generation.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/generation.rs b/src/generation.rs index 7ba7be0..875a134 100644 --- a/src/generation.rs +++ b/src/generation.rs @@ -7036,7 +7036,8 @@ 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)) + variant_deser_failed_block + .line(format!("errs.push(e.annotate(\"{}\"));", variant.name)) .line("raw.to_string();"); return_if_deserialized.push_block(variant_deser_failed_block); return_if_deserialized.after(";");