#[cfg(test)]
mod tests {
mod basic_functionality_tests {
use dtt::error::DateTimeError;
#[test]
fn test_invalid_format() {
let error = DateTimeError::InvalidFormat;
assert_eq!(error.to_string(), "Invalid date format");
let error: &dyn std::error::Error = &error;
assert_eq!(error.to_string(), "Invalid date format");
}
#[test]
fn test_invalid_timezone() {
let error = DateTimeError::InvalidTimezone;
assert_eq!(
error.to_string(),
"Invalid or unsupported timezone; DST not supported"
);
let error: &dyn std::error::Error = &error;
assert_eq!(
error.to_string(),
"Invalid or unsupported timezone; DST not supported"
);
}
#[test]
fn test_invalid_date() {
let error = DateTimeError::InvalidDate;
assert_eq!(error.to_string(), "Invalid date");
}
#[test]
fn test_invalid_time() {
let error = DateTimeError::InvalidTime;
assert_eq!(error.to_string(), "Invalid time");
}
}
mod trait_implementations_tests {
use dtt::error::DateTimeError;
use std::collections::HashSet;
#[test]
fn test_debug_impl() {
let format_error = DateTimeError::InvalidFormat;
let timezone_error = DateTimeError::InvalidTimezone;
assert_eq!(format!("{:?}", format_error), "InvalidFormat");
assert_eq!(
format!("{:?}", timezone_error),
"InvalidTimezone"
);
}
#[test]
fn test_clone_and_copy() {
let original = DateTimeError::InvalidFormat;
let cloned = original;
let copied = original;
assert_eq!(original, cloned);
assert_eq!(original, copied);
}
#[test]
fn test_hash() {
let mut set = HashSet::new();
let _ = set.insert(DateTimeError::InvalidFormat);
let _ = set.insert(DateTimeError::InvalidTimezone);
assert_eq!(set.len(), 2);
assert!(set.contains(&DateTimeError::InvalidFormat));
assert!(set.contains(&DateTimeError::InvalidTimezone));
}
#[test]
fn test_partial_eq() {
let parse_error1 = DateTimeError::InvalidFormat;
let parse_error2 = DateTimeError::InvalidFormat;
let range_error = DateTimeError::InvalidTimezone;
assert_eq!(parse_error1, parse_error2);
assert_ne!(parse_error1, range_error);
}
}
mod serialization_tests {
use dtt::error::DateTimeError;
use time::error::{Parse, TryFromParsed};
#[test]
fn test_serialization() -> Result<(), Box<dyn std::error::Error>>
{
let format_error = DateTimeError::InvalidFormat;
let timezone_error = DateTimeError::InvalidTimezone;
let serialized_format =
serde_json::to_string(&format_error)?;
let serialized_timezone =
serde_json::to_string(&timezone_error)?;
let deserialized_format: DateTimeError =
serde_json::from_str(&serialized_format)?;
let deserialized_timezone: DateTimeError =
serde_json::from_str(&serialized_timezone)?;
assert_eq!(format_error, deserialized_format);
assert_eq!(timezone_error, deserialized_timezone);
Ok(())
}
#[test]
fn test_deserialization(
) -> Result<(), Box<dyn std::error::Error>> {
let format_error_str = "\"InvalidFormat\"";
let timezone_error_str = "\"InvalidTimezone\"";
let deserialized_format: DateTimeError =
serde_json::from_str(format_error_str)?;
let deserialized_timezone: DateTimeError =
serde_json::from_str(timezone_error_str)?;
assert_eq!(
deserialized_format,
DateTimeError::InvalidFormat
);
assert_eq!(
deserialized_timezone,
DateTimeError::InvalidTimezone
);
Ok(())
}
#[test]
fn test_custom_serde_impl(
) -> Result<(), Box<dyn std::error::Error>> {
let format_error = DateTimeError::InvalidFormat;
let serialized_format =
serde_json::to_string(&format_error)?;
assert_eq!(
format_error,
serde_json::from_str(&serialized_format)?
);
let parse_error =
DateTimeError::ParseError(Parse::TryFromParsed(
TryFromParsed::InsufficientInformation,
));
let serialized_parse = serde_json::to_string(&parse_error)?;
assert_eq!(serialized_parse, "\"ParseError\"");
assert!(serde_json::from_str::<DateTimeError>(
&serialized_parse
)
.is_err());
Ok(())
}
#[test]
fn test_from_str() -> Result<(), Box<dyn std::error::Error>> {
let error_str = r#""InvalidFormat""#;
let deserialized: DateTimeError =
serde_json::from_str(error_str)?;
assert_eq!(deserialized, DateTimeError::InvalidFormat);
let error_str = r#""InvalidTimezone""#;
let deserialized: DateTimeError =
serde_json::from_str(error_str)?;
assert_eq!(deserialized, DateTimeError::InvalidTimezone);
let error_str = r#""UnknownError""#;
assert!(serde_json::from_str::<DateTimeError>(error_str)
.is_err());
Ok(())
}
#[test]
fn test_invalid_json_deserialization() {
let invalid_json_str = r#"{ "invalid": "data" }"#;
assert!(serde_json::from_str::<DateTimeError>(
invalid_json_str
)
.is_err());
}
}
mod comparison_and_equality_tests {
use dtt::error::DateTimeError;
#[test]
fn test_eq_and_ne() {
let error1 = DateTimeError::InvalidFormat;
let error2 = DateTimeError::InvalidFormat;
let error3 = DateTimeError::InvalidTimezone;
assert_eq!(error1, error2);
assert_ne!(error1, error3);
}
#[test]
fn test_self_comparison() {
let format_error = DateTimeError::InvalidFormat;
let timezone_error = DateTimeError::InvalidTimezone;
assert_eq!(format_error, format_error);
assert_eq!(timezone_error, timezone_error);
}
#[test]
fn test_eq_for_same_variant() {
let error1 = DateTimeError::InvalidFormat;
let error2 = DateTimeError::InvalidFormat;
assert_eq!(error1, error2);
}
#[test]
fn test_ne_for_different_variants() {
let error1 = DateTimeError::InvalidFormat;
let error2 = DateTimeError::InvalidTimezone;
assert_ne!(error1, error2);
}
#[test]
fn test_different_variants_comparison() {
let format_error = DateTimeError::InvalidFormat;
let timezone_error = DateTimeError::InvalidTimezone;
let date_error = DateTimeError::InvalidDate;
let time_error = DateTimeError::InvalidTime;
assert_ne!(format_error, timezone_error);
assert_ne!(format_error, date_error);
assert_ne!(format_error, time_error);
assert_ne!(timezone_error, date_error);
assert_ne!(timezone_error, time_error);
assert_ne!(date_error, time_error);
}
}
mod error_handling_tests {
use dtt::error::DateTimeError;
use std::error::Error;
#[test]
fn test_error_source() {
let error = DateTimeError::InvalidFormat;
assert!(error.source().is_none());
}
#[test]
fn test_no_unexpected_panics() -> Result<(), Box<dyn Error>> {
let valid_json_format = r#""InvalidFormat""#;
let valid_json_timezone = r#""InvalidTimezone""#;
let _ = serde_json::from_str::<DateTimeError>(
valid_json_format,
)?;
let _ = serde_json::from_str::<DateTimeError>(
valid_json_timezone,
)?;
Ok(())
}
#[test]
fn test_debug_display_impl() {
let format_error = DateTimeError::InvalidFormat;
assert_eq!(format!("{:?}", format_error), "InvalidFormat");
assert_eq!(
format!("{}", format_error),
"Invalid date format"
);
let timezone_error = DateTimeError::InvalidTimezone;
assert_eq!(
format!("{:?}", timezone_error),
"InvalidTimezone"
);
assert_eq!(
format!("{}", timezone_error),
"Invalid or unsupported timezone; DST not supported"
);
}
}
mod future_proofing_tests {
use dtt::error::DateTimeError;
#[test]
fn test_non_exhaustive() {
let parse_error_mock = DateTimeError::InvalidFormat;
let component_range_mock = DateTimeError::InvalidTimezone;
let all_variants = [
DateTimeError::InvalidFormat,
DateTimeError::InvalidTimezone,
DateTimeError::InvalidDate,
DateTimeError::InvalidTime,
parse_error_mock, component_range_mock, ];
for variant in &all_variants {
match variant {
DateTimeError::InvalidFormat => {
assert_eq!(
variant.to_string(),
"Invalid date format"
);
}
DateTimeError::InvalidTimezone => {
assert_eq!(
variant.to_string(),
"Invalid or unsupported timezone; DST not supported"
);
}
DateTimeError::InvalidDate => {
assert_eq!(variant.to_string(), "Invalid date");
}
DateTimeError::InvalidTime => {
assert_eq!(variant.to_string(), "Invalid time");
}
DateTimeError::ParseError(_) => {
assert!(variant
.to_string()
.contains("Parsing error"));
}
DateTimeError::ComponentRange(_) => {
assert!(variant
.to_string()
.contains("Component range error"));
}
}
}
}
}
mod low_level_tests {
use dtt::error::DateTimeError;
use std::mem::size_of;
#[test]
fn test_memory_layout() {
assert_eq!(size_of::<DateTimeError>(), 56);
}
#[test]
fn test_error_serialization(
) -> Result<(), Box<dyn std::error::Error>> {
let error = DateTimeError::InvalidTimezone;
let serialized = serde_json::to_string(&error)?;
assert_eq!(serialized, "\"InvalidTimezone\"");
Ok(())
}
#[test]
fn test_error_deserialization(
) -> Result<(), Box<dyn std::error::Error>> {
let deserialized: DateTimeError =
serde_json::from_str("\"InvalidDate\"")?;
assert_eq!(deserialized, DateTimeError::InvalidDate);
Ok(())
}
}
mod default_implementation_tests {
use dtt::error::DateTimeError;
#[test]
fn test_default_trait() {
let default_error = DateTimeError::default();
assert_eq!(default_error, DateTimeError::InvalidFormat);
}
}
}