chore: Improve en-/decode error messages (#536)

* feat: Make wrapped codec errors display their inner errors as well

* feat: Simplify and harmonize error display for encode/decode errors

Author: decryphe

src/error/decode.rs

@@ -30,6 +30,22 @@ pub enum CodecDecodeError {
     Xer(XerDecodeErrorKind),
 }
 
+impl core::fmt::Display for CodecDecodeError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            CodecDecodeError::Ber(kind) => write!(f, "BER decoding error: {kind}"),
+            CodecDecodeError::Cer(kind) => write!(f, "CER decoding error: {kind}"),
+            CodecDecodeError::Der(kind) => write!(f, "DER decoding error: {kind}"),
+            CodecDecodeError::Uper(kind) => write!(f, "UPER decoding error: {kind}"),
+            CodecDecodeError::Aper(kind) => write!(f, "APER decoding error: {kind}"),
+            CodecDecodeError::Jer(kind) => write!(f, "JER decoding error: {kind}"),
+            CodecDecodeError::Oer(kind) => write!(f, "OER decoding error: {kind}"),
+            CodecDecodeError::Coer(kind) => write!(f, "COER decoding error: {kind}"),
+            CodecDecodeError::Xer(kind) => write!(f, "XER decoding error: {kind}"),
+        }
+    }
+}
+
 macro_rules! impl_from {
     ($variant:ident, $error_kind:ty) => {
         impl From<$error_kind> for DecodeError {
@@ -147,10 +163,9 @@ pub struct DecodeError {
 
 impl core::fmt::Display for DecodeError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        writeln!(f, "Error Kind: {}", self.kind)?;
-        writeln!(f, "Codec: {}", self.codec)?;
+        write!(f, "{} (Codec: {})", self.kind, self.codec)?;
         #[cfg(feature = "backtraces")]
-        write!(f, "\nBacktrace:\n{}", self.backtrace)?;
+        write!(f, "\n\nBacktrace:\n{}", self.backtrace)?;
         Ok(())
     }
 }
@@ -485,15 +500,15 @@ pub enum DecodeErrorKind {
     },
 
     /// Codec specific error.
-    #[snafu(display("Wrapped codec-specific decode error"))]
+    #[snafu(display("{inner}"))]
     CodecSpecific {
         /// The inner error type.
         inner: CodecDecodeError,
     },
 
     /// Enumeration index didn't match any variant.
     #[snafu(display(
-        "Enumeration index '{}' did not match any variant. Extended list: {}",
+        "Enumeration index {} did not match any variant. Extended list checked: {}",
         index,
         extended_list
     ))]
@@ -505,7 +520,7 @@ pub enum DecodeErrorKind {
     },
 
     /// Choice index didn't match any variant.
-    #[snafu(display("choice index '{index}' did not match any variant"))]
+    #[snafu(display("Choice index {index} did not match any variant"))]
     ChoiceIndexNotFound {
         /// The found index of the choice variant.
         index: usize,
@@ -515,7 +530,7 @@ pub enum DecodeErrorKind {
 
     /// Choice index exceeds maximum possible address width.
     #[snafu(display(
-        "integer range larger than possible to address on this platform. needed: {needed} present: {present}"
+        "Choice index exceeds platform index width. Needed {needed} bytes, present: {present}"
     ))]
     ChoiceIndexExceedsPlatformWidth {
         /// Amount of bytes needed.
@@ -525,14 +540,14 @@ pub enum DecodeErrorKind {
     },
 
     /// Uncategorised error.
-    #[snafu(display("Custom: {}", msg))]
+    #[snafu(display("Custom error: {}", msg))]
     Custom {
         /// The error's message.
         msg: alloc::string::String,
     },
 
     /// Discriminant index didn't match any variant.
-    #[snafu(display("Discriminant value '{}' did not match any variant", discriminant))]
+    #[snafu(display("Discriminant value {} did not match any variant", discriminant))]
     DiscriminantValueNotFound {
         /// The found value of the discriminant
         discriminant: isize,
@@ -553,7 +568,7 @@ pub enum DecodeErrorKind {
     },
 
     ///  More than `usize::MAX` number of data requested.
-    #[snafu(display("Length of the incoming data is either exceeds platform address width."))]
+    #[snafu(display("Length of the data exceeds platform address width"))]
     LengthExceedsPlatformWidth {
         /// The specific message of the length error.
         msg: alloc::string::String,
@@ -571,19 +586,19 @@ pub enum DecodeErrorKind {
     /// Input is provided as BIT slice for nom in UPER/APER.
     /// On BER/CER/DER/OER/COER it is a BYTE slice.
     /// Hence, `needed` field can describe either bits or bytes depending on the codec.
-    #[snafu(display("Need more data to continue: ({:?}).", needed))]
+    #[snafu(display("Need more data to continue: {:?}", needed))]
     Incomplete {
         /// Amount of bits/bytes needed.
         needed: nom::Needed,
     },
     /// Encountered EOF when decoding.
     /// BER/CER/DER uses EOF as part of the decoding logic.
-    #[snafu(display("EOF when decoding"))]
+    #[snafu(display("Unexpected EOF when decoding"))]
     Eof,
 
     /// Invalid item number in sequence.
     #[snafu(display(
-        "Invalid item number in Sequence: expected {}, actual {}",
+        "Invalid item number in Sequence: expected: {}; actual: {}",
         expected,
         actual
     ))]
@@ -613,7 +628,7 @@ pub enum DecodeErrorKind {
     InvalidRealEncoding,
 
     /// Decoder doesn't support REAL
-    #[snafu(display("Decoder doesn't support REAL types"))]
+    #[snafu(display("Decoder doesn't support `REAL` type"))]
     RealNotSupported,
 
     /// `BitString` contains an invalid amount of unused bits.
@@ -637,7 +652,7 @@ pub enum DecodeErrorKind {
     #[snafu(display("Length of Length cannot be zero"))]
     ZeroLengthOfLength,
     /// The length does not match what was expected.
-    #[snafu(display("Expected {:?} bytes, actual length: {:?}", expected, actual))]
+    #[snafu(display("Expected {} bytes, actual length was {} bytes", expected, actual))]
     MismatchedLength {
         /// The expected length.
         expected: usize,
@@ -666,7 +681,7 @@ pub enum DecodeErrorKind {
 
     /// The range of the integer exceeds the platform width.
     #[snafu(display(
-        "integer range larger than possible to address on this platform. needed: {needed} present: {present}"
+        "Integer range larger than possible to address on this platform. needed: {needed} present: {present}"
     ))]
     RangeExceedsPlatformWidth {
         /// Amount of bytes needed.
@@ -752,10 +767,10 @@ pub enum DecodeErrorKind {
 #[non_exhaustive]
 pub enum BerDecodeErrorKind {
     /// An error when the length is not definite.
-    #[snafu(display("Indefinite length encountered but not allowed."))]
+    #[snafu(display("Indefinite length encountered but not allowed"))]
     IndefiniteLengthNotAllowed,
     /// An error if the value is not primitive when required.
-    #[snafu(display("Invalid constructed identifier for ASN.1 value: not primitive."))]
+    #[snafu(display("Invalid constructed identifier for ASN.1 value: not primitive"))]
     InvalidConstructedIdentifier,
     /// Invalid date.
     #[snafu(display("Invalid date string: {}", msg))]
@@ -764,7 +779,7 @@ pub enum BerDecodeErrorKind {
         msg: alloc::string::String,
     },
     /// An error when the object identifier is invalid.
-    #[snafu(display("Invalid object identifier with missing or corrupt root nodes."))]
+    #[snafu(display("Invalid object identifier with missing or corrupt root nodes"))]
     InvalidObjectIdentifier,
     /// The tag does not match what was expected.
     #[snafu(display("Expected {:?} tag, actual tag: {:?}", expected, actual))]
@@ -804,7 +819,7 @@ pub enum CerDecodeErrorKind {}
 #[non_exhaustive]
 pub enum DerDecodeErrorKind {
     /// An error when constructed encoding encountered but not allowed.
-    #[snafu(display("Constructed encoding encountered but not allowed."))]
+    #[snafu(display("Constructed encoding encountered but not allowed"))]
     ConstructedEncodingNotAllowed,
 }
 
@@ -814,11 +829,11 @@ pub enum DerDecodeErrorKind {
 #[non_exhaustive]
 pub enum JerDecodeErrorKind {
     /// An error when the end of input is reached, but more data is needed.
-    #[snafu(display("Unexpected end of input while decoding JER JSON."))]
+    #[snafu(display("Unexpected end of input while decoding JER"))]
     EndOfInput {},
     /// An error when the JSON type is not the expected type.
     #[snafu(display(
-        "Found mismatching JSON value. Expected type {}. Found value {}.",
+        "Found mismatching JSON value. Expected type: {}. Found value: {}",
         needed,
         found
     ))]
@@ -829,13 +844,13 @@ pub enum JerDecodeErrorKind {
         found: alloc::string::String,
     },
     /// An error when the JSON value is not a valid bit string.
-    #[snafu(display("Found invalid byte in bit string. {parse_int_err}"))]
+    #[snafu(display("Found invalid byte in bit string: {parse_int_err}"))]
     InvalidJerBitstring {
         /// The error that occurred when parsing the `BitString` byte.
         parse_int_err: ParseIntError,
     },
     /// An error when the JSON value is not a valid octet string.
-    #[snafu(display("Found invalid character in octet string."))]
+    #[snafu(display("Found invalid character in octet string"))]
     InvalidJerOctetString {},
     /// An error when the JSON value is not a valid OID string.
     #[snafu(display("Failed to construct OID from value {value}",))]
@@ -878,11 +893,11 @@ pub enum AperDecodeErrorKind {}
 #[snafu(visibility(pub))]
 #[non_exhaustive]
 pub enum XerDecodeErrorKind {
-    #[snafu(display("Unexpected end of input while decoding XER XML."))]
+    #[snafu(display("Unexpected end of input while decoding XER"))]
     /// An error that indicates that the XML input ended unexpectedly
     EndOfXmlInput {},
     #[snafu(display(
-        "Found mismatching XML value. Expected type {}. Found value {}.",
+        "Found mismatching XML value. Expected type: {}. Found value: {}.",
         needed,
         found
     ))]
@@ -893,13 +908,13 @@ pub enum XerDecodeErrorKind {
         /// the encountered tag type or value
         found: alloc::string::String,
     },
-    #[snafu(display("Found invalid character in octet string."))]
+    #[snafu(display("Found invalid character in octet string"))]
     /// An error that indicates a character in an octet string that does not conform to the hex alphabet
     InvalidXerOctetstring {
         /// Inner error thrown by the `parse` method
         parse_int_err: ParseIntError,
     },
-    #[snafu(display("Encountered invalid value. {details}"))]
+    #[snafu(display("Encountered invalid value: {details}"))]
     /// An error that indicates invalid input XML
     InvalidInput {
         /// Error details from the underlying XML parser
@@ -945,7 +960,7 @@ pub enum OerDecodeErrorKind {
         class: u8,
     },
     /// The tag number was incorrect when decoding a Choice type.
-    #[snafu(display("Invalid tag number when decoding Choice. Value: {value}"))]
+    #[snafu(display("Invalid tag number when decoding Choice: {value}"))]
     InvalidTagNumberOnChoice {
         /// Invalid tag bytes at the time of decoding.
         value: u32,

src/error/encode.rs

@@ -21,6 +21,22 @@ pub enum CodecEncodeError {
     Coer(CoerEncodeErrorKind),
     Xer(XerEncodeErrorKind),
 }
+
+impl core::fmt::Display for CodecEncodeError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            CodecEncodeError::Ber(kind) => write!(f, "BER encoding error: {kind}"),
+            CodecEncodeError::Cer(kind) => write!(f, "CER encoding error: {kind}"),
+            CodecEncodeError::Der(kind) => write!(f, "DER encoding error: {kind}"),
+            CodecEncodeError::Uper(kind) => write!(f, "UPER encoding error: {kind}"),
+            CodecEncodeError::Aper(kind) => write!(f, "APER encoding error: {kind}"),
+            CodecEncodeError::Jer(kind) => write!(f, "JER encoding error: {kind}"),
+            CodecEncodeError::Coer(kind) => write!(f, "COER encoding error: {kind}"),
+            CodecEncodeError::Xer(kind) => write!(f, "XER encoding error: {kind}"),
+        }
+    }
+}
+
 macro_rules! impl_from {
     ($variant:ident, $error_kind:ty) => {
         impl From<$error_kind> for EncodeError {
@@ -117,10 +133,9 @@ impl core::error::Error for EncodeError {}
 
 impl core::fmt::Display for EncodeError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        writeln!(f, "Error Kind: {}", self.kind)?;
-        writeln!(f, "Codec: {}", self.kind)?;
+        write!(f, "{} (Codec: {})", self.kind, self.codec)?;
         #[cfg(feature = "backtraces")]
-        write!(f, "\nBacktrace:\n{}", self.backtrace)?;
+        write!(f, "\n\nBacktrace:\n{}", self.backtrace)?;
 
         Ok(())
     }
@@ -268,19 +283,19 @@ pub enum EncodeErrorKind {
         err: core::num::TryFromIntError,
     },
     /// Error when the length of the data is not in the constraint size range.
-    #[snafu(display("invalid length, expected: {expected}; actual: {length}"))]
+    #[snafu(display("Invalid length, expected: {expected}; actual: {length}"))]
     InvalidLength {
         /// Actual length of the data
         length: usize,
         /// Expected length of the data
         expected: Bounded<usize>,
     },
     /// Error when the length of the data is more than we can technically handle.
-    #[snafu(display("invalid length, exceeds platform maximum size usize::MAX"))]
+    #[snafu(display("Invalid length, exceeds platform maximum size usize::MAX"))]
     LengthExceedsPlatformSize,
     /// Encode error when the
     #[snafu(display(
-        "The provided value does not fit to the reserved octets {expected}; actual: {value}"
+        "The provided value does not fit in the reserved octets {expected}; actual: {value}"
     ))]
     MoreBytesThanExpected {
         /// The count of the provided bytes
@@ -289,13 +304,13 @@ pub enum EncodeErrorKind {
         expected: usize,
     },
     /// Error when the custom error is thrown.
-    #[snafu(display("custom error:\n{}", msg))]
+    #[snafu(display("Custom error: {}", msg))]
     Custom {
         /// The custom error message
         msg: alloc::string::String,
     },
     /// Wraps codec-specific errors as inner [`CodecEncodeError`].
-    #[snafu(display("Wrapped codec-specific encode error"))]
+    #[snafu(display("{inner}"))]
     CodecSpecific {
         /// Inner codec-specific error
         inner: CodecEncodeError,
@@ -323,19 +338,19 @@ pub enum EncodeErrorKind {
         expected: Bounded<i128>,
     },
     /// Error when the type conversion failed between different integer types.
-    #[snafu(display("Failed to cast integer to another integer type: {msg} "))]
+    #[snafu(display("Failed to cast integer to another integer type: {msg}"))]
     IntegerTypeConversionFailed {
         /// More precise error message
         msg: alloc::string::String,
     },
     /// Error mainly used as part of SMI standard which converts type to BER encoding and handles bytes as `Opaque`.
-    #[snafu(display("Conversion to Opaque type failed: {msg}"))]
+    #[snafu(display("Conversion to opaque type failed: {msg}"))]
     OpaqueConversionFailed {
         /// More precise error message
         msg: alloc::string::String,
     },
     /// Error when the selected variant is not found in the choice.
-    #[snafu(display("Selected Variant not found from Choice"))]
+    #[snafu(display("Selected Variant not found in Choice"))]
     VariantNotInChoice,
 
     /// Error when we try to encode a `REAL` type with an unspported codec.
@@ -392,7 +407,7 @@ pub enum JerEncodeErrorKind {
         upstream: alloc::string::String,
     },
     /// Error to be thrown when the JER encoder contains no encoded root value
-    #[snafu(display("No encoded JSON root value found!"))]
+    #[snafu(display("No encoded JSON root value found"))]
     NoRootValueFound,
     /// Internal JSON encoder error
     #[snafu(display("Error in JSON encoder: {}", msg))]
@@ -401,7 +416,7 @@ pub enum JerEncodeErrorKind {
         msg: alloc::string::String,
     },
     /// Error to be thrown when encoding large integers than the supported range
-    #[snafu(display("Exceeds supported integer range -2^63..2^63 ({:?}).", value))]
+    #[snafu(display("Exceeds supported integer range -2^63..2^63 ({:?})", value))]
     ExceedsSupportedIntSize {
         /// value failed to encode
         value: BigInt,
@@ -439,10 +454,10 @@ pub enum XerEncodeErrorKind {
         /// Stringified error of the underlying XML writer
         upstream: alloc::string::String,
     },
-    #[snafu(display("Failed to encode integer."))]
+    #[snafu(display("Failed to encode integer"))]
     /// An error indicating an integer value outside of the supported bounds
     UnsupportedIntegerValue,
-    #[snafu(display("Missing identifier for ASN.1 type."))]
+    #[snafu(display("Missing identifier for ASN.1 type"))]
     /// An error indicating that the XML writer is missing information about the tag name of the item to encode
     MissingIdentifier,
 }
@@ -453,13 +468,13 @@ pub enum XerEncodeErrorKind {
 #[non_exhaustive]
 pub enum CoerEncodeErrorKind {
     /// Error type for a scenario when the provided data is too long to be encoded with COER.
-    #[snafu(display("Provided data is too long to be encoded with COER."))]
+    #[snafu(display("Provided data is too long to be encoded with COER"))]
     TooLongValue {
         /// The length of the provided data
         length: u128,
     },
     /// Error type for a secenario when the provided integer value exceeds the limits of the constrained word sizes.
-    #[snafu(display("Provided integer exceeds limits of the constrained word sizes."))]
+    #[snafu(display("Provided integer exceeds limits of the constrained word sizes"))]
     InvalidConstrainedIntegerOctetSize,
 }