pathkit/

traits.rs

use std::{
    borrow::Borrow,
    fmt::{
        Display,
        Formatter,
        Result as FmtResult,
    },
    ops::Deref,
    path::{
        Path as StdPath,
        PathBuf,
    },
};

use super::core::Path;

impl AsRef<StdPath> for Path {
    fn as_ref(&self) -> &StdPath {
        &self.0
    }
}

impl Borrow<StdPath> for Path {
    fn borrow(&self) -> &StdPath {
        &self.0
    }
}

impl Deref for Path {
    type Target = StdPath;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl Display for Path {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        write!(f, "{}", self.to_string_lossy())
    }
}

impl From<&StdPath> for Path {
    fn from(path: &StdPath) -> Self {
        Self(path.to_path_buf())
    }
}

impl From<Path> for PathBuf {
    fn from(path: Path) -> Self {
        path.0
    }
}

#[cfg(test)]
mod tests {
    use std::{
        borrow::Borrow,
        ops::Deref,
        path::{
            Path as StdPath,
            PathBuf,
        },
    };

    use super::Path;

    // Test AsRef<StdPath>
    #[test]
    fn test_as_ref_std_path() {
        let path = Path::new("/test/path");
        let std_path: &StdPath = path.as_ref();
        assert_eq!(std_path, StdPath::new("/test/path"));
    }

    // Test AsRef<Path> - check that as_ref returns the path through deref
    #[test]
    fn test_as_ref_self() {
        let path = Path::new("/test/path");
        // as_ref returns &StdPath through Deref
        let path_ref = path.as_ref();
        assert_eq!(path_ref, StdPath::new("/test/path"));
    }

    // Test Borrow<StdPath>
    #[test]
    fn test_borrow() {
        let path = Path::new("/test/path");
        let borrowed: &StdPath = path.borrow();
        assert_eq!(borrowed, StdPath::new("/test/path"));
    }

    // Test Deref
    #[test]
    fn test_deref() {
        let path = Path::new("/test/path");
        let dereferenced: &StdPath = path.deref();
        assert_eq!(dereferenced, StdPath::new("/test/path"));
    }

    // Skip Deref target test - Path::target doesn't exist
    // Test Display
    #[test]
    fn test_display() {
        let path = Path::new("/test/path");
        let display: String = path.to_string();
        assert_eq!(display, "/test/path");
    }

    // Test Display format
    #[test]
    fn test_display_format() {
        let path = Path::new("/test/path");
        assert_eq!(format!("{}", path), "/test/path");
    }

    // Test Display with other format specifiers
    #[test]
    fn test_display_format_args() {
        let path = Path::new("file.txt");
        assert_eq!(format!("Path: {}", path), "Path: file.txt");
    }

    // Test From<&StdPath> for Path
    #[test]
    fn test_from_std_path_ref() {
        let std_path = std::path::Path::new("/test/path");
        let path: Path = Path::from(std_path);
        assert_eq!(path.to_str(), Some("/test/path"));
    }

    // Test From<PathBuf> for Path - use Path::new instead
    #[test]
    fn test_from_pathbuf() {
        let pathbuf = PathBuf::from("/test/path");
        let path = Path::new(pathbuf);
        assert_eq!(path.to_path_buf(), PathBuf::from("/test/path"));
    }

    // Test From<Path> for PathBuf
    #[test]
    fn test_from_path_to_pathbuf() {
        let path = Path::new("/test/path");
        let pathbuf: PathBuf = PathBuf::from(path);
        assert_eq!(pathbuf, PathBuf::from("/test/path"));
    }

    // Skip test_from_string - Path doesn't implement From<String>
    // Skip test_from_str - Path doesn't implement From<&str>

    // Test to_string_lossy
    #[test]
    fn test_to_string_lossy() {
        let path = Path::new("/test/path");
        let lost = path.to_string_lossy();
        assert_eq!(lost, "/test/path");
    }

    // Test to_str
    #[test]
    fn test_to_str() {
        let path = Path::new("/test/path");
        assert_eq!(path.to_str(), Some("/test/path"));
    }

    // Test to_str with invalid unicode - simplified
    #[test]
    fn test_to_str_unicode() {
        // Test normal unicode path
        let path = Path::new("/test/文件.txt");
        assert_eq!(path.to_str(), Some("/test/文件.txt"));
    }

    // Test clone
    #[test]
    fn test_clone() {
        let path = Path::new("/test/path");
        let cloned = path.clone();
        assert_eq!(path, cloned);
    }

    // Test clone is independent
    #[test]
    fn test_clone_independence() {
        let mut path1 = Path::new("/test/path");
        let path2 = path1.clone();
        path1 = Path::new("/other/path");
        assert_eq!(path2.to_str(), Some("/test/path"));
        assert_eq!(path1.to_str(), Some("/other/path"));
    }

    // Test equality
    #[test]
    fn test_eq() {
        let path1 = Path::new("/test/path");
        let path2 = Path::new("/test/path");
        let path3 = Path::new("/other/path");

        assert_eq!(path1, path2);
        assert_ne!(path1, path3);
    }

    // Test equality with different types
    #[test]
    fn test_eq_with_std_path() {
        let path = Path::new("/test/path");
        let std_path = StdPath::new("/test/path");
        // Can't directly compare different types without explicit conversion
        assert_eq!(path.as_path(), std_path);
    }

    // Test Debug
    #[test]
    fn test_debug() {
        let path = Path::new("/test/path");
        let debug_str = format!("{:?}", path);
        assert!(debug_str.contains("Path"));
        assert!(debug_str.contains("/test/path"));
    }

    // Test Hash
    #[test]
    fn test_hash() {
        use std::{
            collections::hash_map::DefaultHasher,
            hash::{
                Hash,
                Hasher,
            },
        };

        let path1 = Path::new("/test/path");
        let path2 = Path::new("/test/path");
        let path3 = Path::new("/other/path");

        let mut hasher1 = DefaultHasher::new();
        let mut hasher2 = DefaultHasher::new();
        let mut hasher3 = DefaultHasher::new();

        path1.hash(&mut hasher1);
        path2.hash(&mut hasher2);
        path3.hash(&mut hasher3);

        assert_eq!(hasher1.finish(), hasher2.finish());
        assert_ne!(hasher1.finish(), hasher3.finish());
    }

    // Test PartialEq with PathBuf
    #[test]
    fn test_partial_eq_pathbuf() {
        let path = Path::new("/test/path");
        let pathbuf = PathBuf::from("/test/path");

        assert_eq!(path.as_path(), pathbuf.as_path());
    }

    // Test as_os_str
    #[test]
    fn test_as_os_str() {
        let path = Path::new("/test/path");
        let os_str = path.as_os_str();
        assert_eq!(os_str, std::ffi::OsStr::new("/test/path"));
    }

    // Test that path has content (skip is_empty - it's unstable)
    #[test]
    fn test_path_has_content() {
        let path = Path::new("/test/path");
        // Just verify the path string is not empty
        assert!(!path.to_str().unwrap().is_empty());
    }
}