use core::fmt;
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, Copy, PartialEq)]
pub struct UnknownCryptoError;
impl fmt::Display for UnknownCryptoError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "UnknownCryptoError")
}
}
impl fmt::Debug for UnknownCryptoError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "UnknownCryptoError")
}
}
#[cfg(feature = "safe_api")]
impl std::error::Error for UnknownCryptoError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
None
}
}
#[cfg(feature = "safe_api")]
impl From<getrandom::Error> for UnknownCryptoError {
fn from(_: getrandom::Error) -> Self {
UnknownCryptoError
}
}
#[cfg(feature = "safe_api")]
impl From<ct_codecs::Error> for UnknownCryptoError {
fn from(_: ct_codecs::Error) -> Self {
UnknownCryptoError
}
}
impl From<core::num::ParseIntError> for UnknownCryptoError {
fn from(_: core::num::ParseIntError) -> Self {
UnknownCryptoError
}
}
#[test]
#[cfg(feature = "safe_api")]
fn test_unknown_crypto_error_debug_display() {
let err = format!("{:?}", UnknownCryptoError);
assert_eq!(err, "UnknownCryptoError");
let err = format!("{}", UnknownCryptoError);
assert_eq!(err, "UnknownCryptoError");
}
#[test]
#[cfg(feature = "safe_api")]
fn test_unknown_crypto_from_getrandom() {
use core::num::NonZeroU32;
let err_code = NonZeroU32::new(12).unwrap();
let err_foreign: getrandom::Error = getrandom::Error::from(err_code);
let err = format!("{:?}", UnknownCryptoError::from(err_foreign));
assert_eq!(err, "UnknownCryptoError");
let err = format!("{}", UnknownCryptoError::from(err_foreign));
assert_eq!(err, "UnknownCryptoError");
}
#[test]
#[cfg(feature = "safe_api")]
fn test_source() {
use std::error::Error;
assert!(UnknownCryptoError.source().is_none());
}
#[test]
#[cfg(feature = "safe_api")]
fn test_unknown_crypto_from_decode_error() {
use ct_codecs::Error;
let err_one = Error::InvalidInput;
let err_two = Error::Overflow;
let err = format!(
"{:?}:{}",
UnknownCryptoError::from(err_one),
UnknownCryptoError::from(err_one)
);
assert_eq!(err, "UnknownCryptoError:UnknownCryptoError");
let err = format!(
"{:?}:{}",
UnknownCryptoError::from(err_two),
UnknownCryptoError::from(err_two)
);
assert_eq!(err, "UnknownCryptoError:UnknownCryptoError");
}
#[test]
#[cfg(feature = "safe_api")]
fn test_unknown_crypto_from_parseint_error() {
let err_foreign = "j".parse::<u32>().unwrap_err();
let err = format!(
"{:?}:{}",
UnknownCryptoError::from(err_foreign.clone()),
UnknownCryptoError::from(err_foreign)
);
assert_eq!(err, "UnknownCryptoError:UnknownCryptoError");
}