Address lints for tests, benchmarks

benchmarks/main.rs

@@ -1,5 +1,9 @@
+//! Benchmarks for `time`.
+//!
+//! These benchmarks are not very precise, but they're good enough to catch major performance
+//! regressions. Run them if you think that may be the case. CI **does not** run benchmarks.
+
 #![allow(
-    missing_docs,
     clippy::missing_docs_in_private_items,
     clippy::std_instead_of_core, // irrelevant for benchmarks
     clippy::std_instead_of_alloc, // irrelevant for benchmarks

tests/derives.rs

@@ -17,13 +17,14 @@ macro_rules! assert_cloned_eq {
 }
 
 fn component_range_error() -> error::ComponentRange {
-    Time::from_hms(24, 0, 0).unwrap_err()
+    Time::from_hms(24, 0, 0).expect_err("24 is not a valid hour")
 }
 
 fn invalid_format_description() -> error::InvalidFormatDescription {
-    format_description::parse("[").unwrap_err()
+    format_description::parse("[").expect_err("format description is invalid")
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn clone() {
     let instant = Instant::now();

tests/duration.rs

@@ -475,6 +475,7 @@ fn time_fn() {
     assert_eq!(value, 0);
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn display() {
     assert_eq!(0.seconds().to_string(), "0s");

tests/error.rs

@@ -31,38 +31,29 @@ macro_rules! assert_source {
 }
 
 fn component_range() -> ComponentRange {
-    Date::from_ordinal_date(0, 367).unwrap_err()
+    Date::from_ordinal_date(0, 367).expect_err("367 is not a valid day")
 }
 
 fn insufficient_type_information() -> Format {
     Time::MIDNIGHT
         .format(&time::format_description::well_known::Rfc3339)
-        .unwrap_err()
+        .expect_err("missing date and UTC offset")
 }
 
 fn unexpected_trailing_characters() -> Parse {
-    Time::parse("a", format_description!("")).unwrap_err()
+    Time::parse("a", format_description!("")).expect_err("should fail to parse")
 }
 
-// fn unexpected_trailing_characters() -> ParseFromDescription {
-//     match Time::parse("0", format_description!("[end]")) {
-//         Err(Parse::ParseFromDescription(
-//             err @ ParseFromDescription::UnexpectedTrailingCharacters { .. },
-//         )) => err,
-//         _ => panic!("unexpected result"),
-//     }
-// }
-
 fn invalid_format_description() -> InvalidFormatDescription {
-    format_description::parse("[").unwrap_err()
+    format_description::parse("[").expect_err("format description is invalid")
 }
 
 fn io_error() -> io::Error {
     io::Error::last_os_error()
 }
 
 fn invalid_literal() -> ParseFromDescription {
-    Parsed::parse_literal(b"a", b"b").unwrap_err()
+    Parsed::parse_literal(b"a", b"b").expect_err("should fail to parse")
 }
 
 #[test]
@@ -166,6 +157,7 @@ fn component_name() {
     assert_eq!(component_range().name(), "ordinal");
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn conversion() {
     assert!(ComponentRange::try_from(Error::from(component_range())).is_ok());

tests/formatting.rs

@@ -564,6 +564,7 @@ fn insufficient_type_information() {
     assert_insufficient_type_information(datetime!(2021-001 0:00).format(&Iso8601::DEFAULT));
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn failed_write() -> time::Result<()> {
     macro_rules! assert_err {

tests/macros.rs

@@ -297,7 +297,7 @@ fn format_description_coverage() {
     assert_eq!(
         format_description!("[ignore count:2]"),
         &[FormatItem::Component(Component::Ignore(Ignore::count(
-            NonZeroU16::new(2).unwrap()
+            NonZeroU16::new(2).expect("2 is not zero")
         )))]
     );
     assert_eq!(

tests/main.rs

@@ -3,8 +3,6 @@
     clippy::std_instead_of_core, // irrelevant for tests
     clippy::std_instead_of_alloc, // irrelevant for tests
     clippy::alloc_instead_of_core, // irrelevant for tests
-    clippy::cognitive_complexity, // TODO split up tests as necessary
-    clippy::unwrap_used, // TODO convert to expect or better error handling
 )]
 
 #[cfg(not(all(

tests/meta.rs

@@ -22,6 +22,7 @@ use time::{
     UtcOffset, Weekday,
 };
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn alignment() {
     macro_rules! assert_alignment {
@@ -89,6 +90,7 @@ fn alignment() {
     assert_alignment!(modifier::YearRepr, 1);
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn size() {
     macro_rules! assert_size {

tests/month.rs

@@ -32,6 +32,7 @@ fn next() {
     assert_eq!(December.next(), January);
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn nth_next() {
     assert_eq!(January.nth_next(0), January);
@@ -66,6 +67,7 @@ fn nth_next() {
     assert_eq!(December.nth_next(u8::MAX), March);
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn nth_prev() {
     assert_eq!(January.nth_prev(0), January);

tests/offset_date_time.rs

@@ -16,7 +16,7 @@ fn now_utc() {
 fn now_local() {
     use time::util::local_offset::*;
 
-    let _guard = crate::SOUNDNESS_LOCK.lock().unwrap();
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
 
     // Safety: Technically not sound. However, this is a test, and it's highly improbable that we
     // will run into issues with setting an environment variable a few times.
@@ -73,9 +73,8 @@ fn checked_to_offset() {
     assert_eq!(
         datetime!(2000-01-01 0:00 UTC)
             .checked_to_offset(offset!(-1))
-            .unwrap()
-            .year(),
-        1999,
+            .map(|odt| odt.year()),
+        Some(1999),
     );
     assert_eq!(
         PrimitiveDateTime::MAX

tests/parse_format_description.rs

@@ -317,6 +317,7 @@ fn simple_component() {
     );
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn errors() {
     use InvalidFormatDescription::*;
@@ -349,6 +350,7 @@ fn errors() {
     }
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn component_with_modifiers() {
     for (padding, padding_str) in iterator::padding() {
@@ -795,6 +797,7 @@ fn nested_error() {
     ));
 }
 
+#[allow(clippy::unwrap_used)] // It's the point of the test.
 #[test]
 fn error_display() {
     assert_eq!(

tests/parsing.rs

@@ -114,6 +114,7 @@ fn rfc_2822() -> time::Result<()> {
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn rfc_2822_err() {
     // In the first test, the "weekday" component is invalid, we're actually testing the whitespace
@@ -326,6 +327,7 @@ fn rfc_3339() -> time::Result<()> {
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn rfc_3339_err() {
     assert!(matches!(
@@ -683,6 +685,7 @@ fn parse_time() -> time::Result<()> {
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn parse_time_err() -> time::Result<()> {
     assert!(matches!(
@@ -871,6 +874,7 @@ fn parse_date() -> time::Result<()> {
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn parse_date_err() -> time::Result<()> {
     assert!(matches!(
@@ -1107,6 +1111,7 @@ fn parse_offset_date_time_err() -> time::Result<()> {
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn parse_components() -> time::Result<()> {
     macro_rules! parse_component {
@@ -1389,13 +1394,13 @@ fn parse_components() -> time::Result<()> {
     let mut parsed = Parsed::new();
     let result = parsed.parse_component(
         b"abcdef",
-        Component::Ignore(Ignore::count(NonZeroU16::new(3).unwrap())),
+        Component::Ignore(Ignore::count(NonZeroU16::new(3).expect("3 is not zero"))),
     )?;
     assert_eq!(result, b"def");
     let mut parsed = Parsed::new();
     let result = parsed.parse_component(
         b"abcdef",
-        Component::Ignore(Ignore::count(NonZeroU16::new(7).unwrap())),
+        Component::Ignore(Ignore::count(NonZeroU16::new(7).expect("7 is not zero"))),
     );
     assert!(matches!(
         result,
@@ -1496,6 +1501,7 @@ fn parse_optional() -> time::Result<()> {
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)] // all test the same thing
 #[test]
 fn parse_first() -> time::Result<()> {
     // Ensure the first item is parsed correctly.
@@ -1576,7 +1582,7 @@ fn parse_first() -> time::Result<()> {
                 FormatItem::Compound(&fd::parse("x")?),
             ]),
         )
-        .unwrap_err();
+        .expect_err("parsing should fail");
     assert_eq!(err, error::ParseFromDescription::InvalidComponent("period"));
 
     let mut parsed = Parsed::new();
@@ -1588,7 +1594,7 @@ fn parse_first() -> time::Result<()> {
                 FormatItem::Compound(&fd::parse("x")?),
             ])),
         )
-        .unwrap_err();
+        .expect_err("parsing should fail");
     assert_eq!(err, error::ParseFromDescription::InvalidComponent("period"));
 
     Ok(())
@@ -1665,11 +1671,10 @@ fn parse_unix_timestamp_err() -> time::Result<()> {
 fn issue_601() {
     let date = OffsetDateTime::parse(
         "1234567890.123",
-        &fd::parse("[unix_timestamp].[subsecond digits:3]").unwrap(),
-    )
-    .unwrap();
+        &fd::parse("[unix_timestamp].[subsecond digits:3]").expect("format description is valid"),
+    );
 
-    assert_eq!(date, datetime!(2009-02-13 23:31:30.123 +00:00:00));
+    assert_eq!(date, Ok(datetime!(2009-02-13 23:31:30.123 +00:00:00)));
 }
 
 #[test]

tests/utc_offset.rs

@@ -149,7 +149,7 @@ fn neg() {
 fn local_offset_at() {
     use time::util::local_offset::*;
 
-    let _guard = crate::SOUNDNESS_LOCK.lock().unwrap();
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
 
     // Safety: Technically not sound. However, this is a test, and it's highly improbable that we
     // will run into issues with setting an environment variable a few times.
@@ -164,7 +164,7 @@ fn local_offset_at() {
 fn current_local_offset() {
     use time::util::local_offset::*;
 
-    let _guard = crate::SOUNDNESS_LOCK.lock().unwrap();
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
 
     // Safety: Technically not sound. However, this is a test, and it's highly improbable that we
     // will run into issues with setting an environment variable a few times.
@@ -185,7 +185,7 @@ fn current_local_offset() {
     ignore
 )]
 fn local_offset_error_when_multithreaded() {
-    let _guard = crate::SOUNDNESS_LOCK.lock().unwrap();
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
 
     std::thread::spawn(|| {
         assert!(UtcOffset::current_local_offset().is_err());

tests/util.rs

@@ -81,7 +81,7 @@ fn weeks_in_year() {
 fn local_offset_soundness() {
     use time::util::local_offset::*;
 
-    let _guard = crate::SOUNDNESS_LOCK.lock().unwrap();
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
 
     assert_eq!(get_soundness(), Soundness::Sound);
     // Safety: Technically not sound. However, this is a test, and it's highly improbable that we