add Error test, fix clippy

2026-08-07 05:43:14 +00:00 · 2025-06-09 11:29:23 +08:00
parent 96de65ebab
commit 91c099e35f
108 changed files with 1594 additions and 282 deletions
@@ -176,3 +176,378 @@ pub fn is_io_eof(e: &Error) -> bool {
        _ => false,
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::{Error as IoError, ErrorKind};
+
+    #[test]
+    fn test_filemeta_error_from_io_error() {
+        let io_error = IoError::new(ErrorKind::PermissionDenied, "permission denied");
+        let filemeta_error: Error = io_error.into();
+
+        match filemeta_error {
+            Error::Io(inner_io) => {
+                assert_eq!(inner_io.kind(), ErrorKind::PermissionDenied);
+                assert!(inner_io.to_string().contains("permission denied"));
+            }
+            _ => panic!("Expected Io variant"),
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_other_function() {
+        let custom_error = "Custom filemeta error";
+        let filemeta_error = Error::other(custom_error);
+
+        match filemeta_error {
+            Error::Io(io_error) => {
+                assert!(io_error.to_string().contains(custom_error));
+                assert_eq!(io_error.kind(), ErrorKind::Other);
+            }
+            _ => panic!("Expected Io variant"),
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_conversions() {
+        // Test various error conversions
+        let serde_decode_err =
+            rmp_serde::decode::Error::InvalidMarkerRead(std::io::Error::new(ErrorKind::InvalidData, "invalid"));
+        let filemeta_error: Error = serde_decode_err.into();
+        assert!(matches!(filemeta_error, Error::RmpSerdeDecode(_)));
+
+        // Test with string-based error that we can actually create
+        let encode_error_string = "test encode error";
+        let filemeta_error = Error::RmpSerdeEncode(encode_error_string.to_string());
+        assert!(matches!(filemeta_error, Error::RmpSerdeEncode(_)));
+
+        let utf8_err = std::string::String::from_utf8(vec![0xFF]).unwrap_err();
+        let filemeta_error: Error = utf8_err.into();
+        assert!(matches!(filemeta_error, Error::FromUtf8(_)));
+    }
+
+    #[test]
+    fn test_filemeta_error_clone() {
+        let test_cases = vec![
+            Error::FileNotFound,
+            Error::FileVersionNotFound,
+            Error::VolumeNotFound,
+            Error::FileCorrupt,
+            Error::DoneForNow,
+            Error::MethodNotAllowed,
+            Error::Unexpected,
+            Error::Io(IoError::new(ErrorKind::NotFound, "test")),
+            Error::RmpSerdeDecode("test decode error".to_string()),
+            Error::RmpSerdeEncode("test encode error".to_string()),
+            Error::FromUtf8("test utf8 error".to_string()),
+            Error::RmpDecodeValueRead("test value read error".to_string()),
+            Error::RmpEncodeValueWrite("test value write error".to_string()),
+            Error::RmpDecodeNumValueRead("test num read error".to_string()),
+            Error::RmpDecodeMarkerRead("test marker read error".to_string()),
+            Error::TimeComponentRange("test time error".to_string()),
+            Error::UuidParse("test uuid error".to_string()),
+        ];
+
+        for original_error in test_cases {
+            let cloned_error = original_error.clone();
+            assert_eq!(original_error, cloned_error);
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_partial_eq() {
+        // Test equality for simple variants
+        assert_eq!(Error::FileNotFound, Error::FileNotFound);
+        assert_ne!(Error::FileNotFound, Error::FileVersionNotFound);
+
+        // Test equality for Io variants
+        let io1 = Error::Io(IoError::new(ErrorKind::NotFound, "test"));
+        let io2 = Error::Io(IoError::new(ErrorKind::NotFound, "test"));
+        let io3 = Error::Io(IoError::new(ErrorKind::PermissionDenied, "test"));
+        assert_eq!(io1, io2);
+        assert_ne!(io1, io3);
+
+        // Test equality for string variants
+        let decode1 = Error::RmpSerdeDecode("error message".to_string());
+        let decode2 = Error::RmpSerdeDecode("error message".to_string());
+        let decode3 = Error::RmpSerdeDecode("different message".to_string());
+        assert_eq!(decode1, decode2);
+        assert_ne!(decode1, decode3);
+    }
+
+    #[test]
+    fn test_filemeta_error_display() {
+        let test_cases = vec![
+            (Error::FileNotFound, "File not found"),
+            (Error::FileVersionNotFound, "File version not found"),
+            (Error::VolumeNotFound, "Volume not found"),
+            (Error::FileCorrupt, "File corrupt"),
+            (Error::DoneForNow, "Done for now"),
+            (Error::MethodNotAllowed, "Method not allowed"),
+            (Error::Unexpected, "Unexpected error"),
+            (Error::RmpSerdeDecode("test".to_string()), "rmp serde decode error: test"),
+            (Error::RmpSerdeEncode("test".to_string()), "rmp serde encode error: test"),
+            (Error::FromUtf8("test".to_string()), "Invalid UTF-8: test"),
+            (Error::TimeComponentRange("test".to_string()), "time component range error: test"),
+            (Error::UuidParse("test".to_string()), "uuid parse error: test"),
+        ];
+
+        for (error, expected_message) in test_cases {
+            assert_eq!(error.to_string(), expected_message);
+        }
+    }
+
+    #[test]
+    fn test_rmp_conversions() {
+        // Test rmp value read error (this one works since it has the same signature)
+        let value_read_err = rmp::decode::ValueReadError::InvalidMarkerRead(std::io::Error::new(ErrorKind::InvalidData, "test"));
+        let filemeta_error: Error = value_read_err.into();
+        assert!(matches!(filemeta_error, Error::RmpDecodeValueRead(_)));
+
+        // Test rmp num value read error
+        let num_value_err =
+            rmp::decode::NumValueReadError::InvalidMarkerRead(std::io::Error::new(ErrorKind::InvalidData, "test"));
+        let filemeta_error: Error = num_value_err.into();
+        assert!(matches!(filemeta_error, Error::RmpDecodeNumValueRead(_)));
+    }
+
+    #[test]
+    fn test_time_and_uuid_conversions() {
+        // Test time component range error
+        use time::{Date, Month};
+        let time_result = Date::from_calendar_date(2023, Month::January, 32); // Invalid day
+        assert!(time_result.is_err());
+        let time_error = time_result.unwrap_err();
+        let filemeta_error: Error = time_error.into();
+        assert!(matches!(filemeta_error, Error::TimeComponentRange(_)));
+
+        // Test UUID parse error
+        let uuid_result = uuid::Uuid::parse_str("invalid-uuid");
+        assert!(uuid_result.is_err());
+        let uuid_error = uuid_result.unwrap_err();
+        let filemeta_error: Error = uuid_error.into();
+        assert!(matches!(filemeta_error, Error::UuidParse(_)));
+    }
+
+    #[test]
+    fn test_marker_read_error_conversion() {
+        // Test rmp marker read error conversion
+        let marker_err = rmp::decode::MarkerReadError(std::io::Error::new(ErrorKind::InvalidData, "marker test"));
+        let filemeta_error: Error = marker_err.into();
+        assert!(matches!(filemeta_error, Error::RmpDecodeMarkerRead(_)));
+        assert!(filemeta_error.to_string().contains("marker"));
+    }
+
+    #[test]
+    fn test_is_io_eof_function() {
+        // Test is_io_eof helper function
+        let eof_error = Error::Io(IoError::new(ErrorKind::UnexpectedEof, "eof"));
+        assert!(is_io_eof(&eof_error));
+
+        let not_eof_error = Error::Io(IoError::new(ErrorKind::NotFound, "not found"));
+        assert!(!is_io_eof(&not_eof_error));
+
+        let non_io_error = Error::FileNotFound;
+        assert!(!is_io_eof(&non_io_error));
+    }
+
+    #[test]
+    fn test_filemeta_error_to_io_error_conversion() {
+        // Test conversion from FileMeta Error to io::Error through other function
+        let original_io_error = IoError::new(ErrorKind::InvalidData, "test data");
+        let filemeta_error = Error::other(original_io_error);
+
+        match filemeta_error {
+            Error::Io(io_err) => {
+                assert_eq!(io_err.kind(), ErrorKind::Other);
+                assert!(io_err.to_string().contains("test data"));
+            }
+            _ => panic!("Expected Io variant"),
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_roundtrip_conversion() {
+        // Test roundtrip conversion: io::Error -> FileMeta Error -> io::Error
+        let original_io_error = IoError::new(ErrorKind::PermissionDenied, "permission test");
+
+        // Convert to FileMeta Error
+        let filemeta_error: Error = original_io_error.into();
+
+        // Extract the io::Error back
+        match filemeta_error {
+            Error::Io(extracted_io_error) => {
+                assert_eq!(extracted_io_error.kind(), ErrorKind::PermissionDenied);
+                assert!(extracted_io_error.to_string().contains("permission test"));
+            }
+            _ => panic!("Expected Io variant"),
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_io_error_kinds_preservation() {
+        let io_error_kinds = vec![
+            ErrorKind::NotFound,
+            ErrorKind::PermissionDenied,
+            ErrorKind::ConnectionRefused,
+            ErrorKind::ConnectionReset,
+            ErrorKind::ConnectionAborted,
+            ErrorKind::NotConnected,
+            ErrorKind::AddrInUse,
+            ErrorKind::AddrNotAvailable,
+            ErrorKind::BrokenPipe,
+            ErrorKind::AlreadyExists,
+            ErrorKind::WouldBlock,
+            ErrorKind::InvalidInput,
+            ErrorKind::InvalidData,
+            ErrorKind::TimedOut,
+            ErrorKind::WriteZero,
+            ErrorKind::Interrupted,
+            ErrorKind::UnexpectedEof,
+            ErrorKind::Other,
+        ];
+
+        for kind in io_error_kinds {
+            let io_error = IoError::new(kind, format!("test error for {:?}", kind));
+            let filemeta_error: Error = io_error.into();
+
+            match filemeta_error {
+                Error::Io(extracted_io_error) => {
+                    assert_eq!(extracted_io_error.kind(), kind);
+                    assert!(extracted_io_error.to_string().contains("test error"));
+                }
+                _ => panic!("Expected Io variant for kind {:?}", kind),
+            }
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_downcast_chain() {
+        // Test error downcast chain functionality
+        let original_io_error = IoError::new(ErrorKind::InvalidData, "original error");
+        let filemeta_error = Error::other(original_io_error);
+
+        // The error should be wrapped as an Io variant
+        if let Error::Io(io_err) = filemeta_error {
+            // The wrapped error should be Other kind (from std::io::Error::other)
+            assert_eq!(io_err.kind(), ErrorKind::Other);
+            // But the message should still contain the original error information
+            assert!(io_err.to_string().contains("original error"));
+        } else {
+            panic!("Expected Io variant");
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_maintains_error_information() {
+        let test_cases = vec![
+            (ErrorKind::NotFound, "file not found"),
+            (ErrorKind::PermissionDenied, "access denied"),
+            (ErrorKind::InvalidData, "corrupt data"),
+            (ErrorKind::TimedOut, "operation timed out"),
+        ];
+
+        for (kind, message) in test_cases {
+            let io_error = IoError::new(kind, message);
+            let error_message = io_error.to_string();
+            let filemeta_error: Error = io_error.into();
+
+            match filemeta_error {
+                Error::Io(extracted_io_error) => {
+                    assert_eq!(extracted_io_error.kind(), kind);
+                    assert_eq!(extracted_io_error.to_string(), error_message);
+                }
+                _ => panic!("Expected Io variant"),
+            }
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_complex_conversion_chain() {
+        // Test conversion from string error types that we can actually create
+
+        // Test with UUID error conversion
+        let uuid_result = uuid::Uuid::parse_str("invalid-uuid-format");
+        assert!(uuid_result.is_err());
+        let uuid_error = uuid_result.unwrap_err();
+        let filemeta_error: Error = uuid_error.into();
+
+        match filemeta_error {
+            Error::UuidParse(message) => {
+                assert!(message.contains("invalid"));
+            }
+            _ => panic!("Expected UuidParse variant"),
+        }
+
+        // Test with time error conversion
+        use time::{Date, Month};
+        let time_result = Date::from_calendar_date(2023, Month::January, 32); // Invalid day
+        assert!(time_result.is_err());
+        let time_error = time_result.unwrap_err();
+        let filemeta_error2: Error = time_error.into();
+
+        match filemeta_error2 {
+            Error::TimeComponentRange(message) => {
+                assert!(message.contains("range"));
+            }
+            _ => panic!("Expected TimeComponentRange variant"),
+        }
+
+        // Test with UTF8 error conversion
+        let utf8_result = std::string::String::from_utf8(vec![0xFF]);
+        assert!(utf8_result.is_err());
+        let utf8_error = utf8_result.unwrap_err();
+        let filemeta_error3: Error = utf8_error.into();
+
+        match filemeta_error3 {
+            Error::FromUtf8(message) => {
+                assert!(message.contains("utf"));
+            }
+            _ => panic!("Expected FromUtf8 variant"),
+        }
+    }
+
+    #[test]
+    fn test_filemeta_error_equality_with_io_errors() {
+        // Test equality comparison for Io variants
+        let io_error1 = IoError::new(ErrorKind::NotFound, "test message");
+        let io_error2 = IoError::new(ErrorKind::NotFound, "test message");
+        let io_error3 = IoError::new(ErrorKind::PermissionDenied, "test message");
+        let io_error4 = IoError::new(ErrorKind::NotFound, "different message");
+
+        let filemeta_error1 = Error::Io(io_error1);
+        let filemeta_error2 = Error::Io(io_error2);
+        let filemeta_error3 = Error::Io(io_error3);
+        let filemeta_error4 = Error::Io(io_error4);
+
+        // Same kind and message should be equal
+        assert_eq!(filemeta_error1, filemeta_error2);
+
+        // Different kinds should not be equal
+        assert_ne!(filemeta_error1, filemeta_error3);
+
+        // Different messages should not be equal
+        assert_ne!(filemeta_error1, filemeta_error4);
+    }
+
+    #[test]
+    fn test_filemeta_error_clone_io_variants() {
+        let io_error = IoError::new(ErrorKind::ConnectionReset, "connection lost");
+        let original_error = Error::Io(io_error);
+        let cloned_error = original_error.clone();
+
+        // Cloned error should be equal to original
+        assert_eq!(original_error, cloned_error);
+
+        // Both should maintain the same properties
+        match (original_error, cloned_error) {
+            (Error::Io(orig_io), Error::Io(cloned_io)) => {
+                assert_eq!(orig_io.kind(), cloned_io.kind());
+                assert_eq!(orig_io.to_string(), cloned_io.to_string());
+            }
+            _ => panic!("Both should be Io variants"),
+        }
+    }
+}
@@ -27,11 +27,7 @@ impl InlineData {
    }

    pub fn after_version(&self) -> &[u8] {
-        if self.0.is_empty() {
-            &self.0
-        } else {
-            &self.0[1..]
-        }
+        if self.0.is_empty() { &self.0 } else { &self.0[1..] }
    }

    pub fn find(&self, key: &str) -> Result<Option<Vec<u8>>> {
@@ -1,5 +1,5 @@
 use crate::error::{Error, Result};
-use crate::{merge_file_meta_versions, FileInfo, FileInfoVersions, FileMeta, FileMetaShallowVersion, VersionType};
+use crate::{FileInfo, FileInfoVersions, FileMeta, FileMetaShallowVersion, VersionType, merge_file_meta_versions};
 use rmp::Marker;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
@@ -10,8 +10,8 @@ use std::{
    pin::Pin,
    ptr,
    sync::{
-        atomic::{AtomicPtr, AtomicU64, Ordering as AtomicOrdering},
        Arc,
+        atomic::{AtomicPtr, AtomicU64, Ordering as AtomicOrdering},
    },
    time::{Duration, SystemTime, UNIX_EPOCH},
 };