lcpfs 2026.1.102

//! FUSE filesystem adapter implementation.
//!
//! Maps FUSE operations to LCPFS Pool methods.

use crate::{DirEntry, FileStat, FileType, Pool};
use fuser::{
    FileAttr, FileType as FuseFileType, Filesystem, ReplyAttr, ReplyData, ReplyDirectory,
    ReplyEntry, ReplyOpen, ReplyWrite, Request, TimeOrNow,
};
use std::collections::HashMap;
use std::ffi::OsStr;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

/// Time-to-live for cached attributes (1 second).
const TTL: Duration = Duration::from_secs(1);

/// Convert LCPFS FileType to FUSE FileType.
fn to_fuse_file_type(ft: FileType) -> FuseFileType {
    match ft {
        FileType::RegularFile => FuseFileType::RegularFile,
        FileType::Directory => FuseFileType::Directory,
        FileType::Symlink => FuseFileType::Symlink,
        FileType::BlockDevice => FuseFileType::BlockDevice,
        FileType::CharDevice => FuseFileType::CharDevice,
        FileType::Fifo => FuseFileType::NamedPipe,
        FileType::Socket => FuseFileType::Socket,
    }
}

/// Convert LCPFS FileStat to FUSE FileAttr.
fn to_file_attr(stat: &FileStat, ino: u64) -> FileAttr {
    let kind = to_fuse_file_type(stat.file_type);

    // Convert timestamps (assume nanoseconds since epoch)
    let atime = UNIX_EPOCH + Duration::from_nanos(stat.atime as u64);
    let mtime = UNIX_EPOCH + Duration::from_nanos(stat.mtime as u64);
    let ctime = UNIX_EPOCH + Duration::from_nanos(stat.ctime as u64);

    FileAttr {
        ino,
        size: stat.size,
        blocks: (stat.size + 511) / 512, // 512-byte blocks
        atime,
        mtime,
        ctime,
        crtime: ctime, // Use ctime as creation time
        kind,
        perm: stat.mode as u16,
        nlink: stat.nlink as u32,
        uid: stat.uid,
        gid: stat.gid,
        rdev: 0,
        blksize: 4096,
        flags: 0,
    }
}

/// LCPFS FUSE filesystem adapter.
///
/// Wraps an LCPFS Pool and exposes it via FUSE.
pub struct LcpfsFuse {
    /// The underlying LCPFS pool.
    pool: Arc<Mutex<Pool>>,

    /// Inode to path mapping.
    inode_to_path: Mutex<HashMap<u64, String>>,

    /// Path to inode mapping.
    path_to_inode: Mutex<HashMap<String, u64>>,

    /// Next available inode number.
    next_inode: Mutex<u64>,

    /// Open file handles: fh -> (path, fd).
    open_files: Mutex<HashMap<u64, (String, u64)>>,

    /// Next file handle.
    next_fh: Mutex<u64>,
}

impl LcpfsFuse {
    /// Create a new FUSE adapter for an LCPFS pool.
    pub fn new(pool: Pool) -> Self {
        let mut inode_to_path = HashMap::new();
        let mut path_to_inode = HashMap::new();

        // Root directory is always inode 1
        inode_to_path.insert(1, "/".to_string());
        path_to_inode.insert("/".to_string(), 1);

        Self {
            pool: Arc::new(Mutex::new(pool)),
            inode_to_path: Mutex::new(inode_to_path),
            path_to_inode: Mutex::new(path_to_inode),
            next_inode: Mutex::new(2), // Start at 2 (1 is root)
            open_files: Mutex::new(HashMap::new()),
            next_fh: Mutex::new(1),
        }
    }

    /// Get or create an inode for a path.
    fn get_or_create_inode(&self, path: &str) -> u64 {
        let mut path_to_inode = self.path_to_inode.lock().unwrap();
        let mut inode_to_path = self.inode_to_path.lock().unwrap();

        if let Some(&ino) = path_to_inode.get(path) {
            return ino;
        }

        let mut next = self.next_inode.lock().unwrap();
        let ino = *next;
        *next += 1;

        path_to_inode.insert(path.to_string(), ino);
        inode_to_path.insert(ino, path.to_string());

        ino
    }

    /// Get path for an inode.
    fn get_path(&self, ino: u64) -> Option<String> {
        self.inode_to_path.lock().unwrap().get(&ino).cloned()
    }

    /// Join parent path with child name.
    fn join_path(parent: &str, name: &str) -> String {
        if parent == "/" {
            format!("/{}", name)
        } else {
            format!("{}/{}", parent, name)
        }
    }

    /// Allocate a new file handle.
    fn alloc_fh(&self, path: String, fd: u64) -> u64 {
        let mut next = self.next_fh.lock().unwrap();
        let fh = *next;
        *next += 1;

        self.open_files.lock().unwrap().insert(fh, (path, fd));
        fh
    }

    /// Get file descriptor for a file handle.
    fn get_fd(&self, fh: u64) -> Option<u64> {
        self.open_files.lock().unwrap().get(&fh).map(|(_, fd)| *fd)
    }

    /// Remove a file handle.
    fn remove_fh(&self, fh: u64) -> Option<(String, u64)> {
        self.open_files.lock().unwrap().remove(&fh)
    }
}

impl Filesystem for LcpfsFuse {
    /// Look up a directory entry by name.
    fn lookup(&mut self, _req: &Request<'_>, parent: u64, name: &OsStr, reply: ReplyEntry) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let name_str = name.to_string_lossy();
        let path = Self::join_path(&parent_path, &name_str);

        let pool = self.pool.lock().unwrap();
        match pool.stat(&path) {
            Ok(stat) => {
                let ino = self.get_or_create_inode(&path);
                let attr = to_file_attr(&stat, ino);
                reply.entry(&TTL, &attr, 0);
            }
            Err(_) => {
                reply.error(libc::ENOENT);
            }
        }
    }

    /// Get file attributes.
    fn getattr(&mut self, _req: &Request<'_>, ino: u64, _fh: Option<u64>, reply: ReplyAttr) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let pool = self.pool.lock().unwrap();
        match pool.stat(&path) {
            Ok(stat) => {
                let attr = to_file_attr(&stat, ino);
                reply.attr(&TTL, &attr);
            }
            Err(_) => {
                reply.error(libc::ENOENT);
            }
        }
    }

    /// Set file attributes (chmod, chown, truncate, utimes).
    fn setattr(
        &mut self,
        _req: &Request<'_>,
        ino: u64,
        mode: Option<u32>,
        uid: Option<u32>,
        gid: Option<u32>,
        size: Option<u64>,
        _atime: Option<TimeOrNow>,
        _mtime: Option<TimeOrNow>,
        _ctime: Option<SystemTime>,
        _fh: Option<u64>,
        _crtime: Option<SystemTime>,
        _chgtime: Option<SystemTime>,
        _bkuptime: Option<SystemTime>,
        _flags: Option<u32>,
        reply: ReplyAttr,
    ) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let mut pool = self.pool.lock().unwrap();

        // Handle chmod
        if let Some(new_mode) = mode {
            if pool.chmod(&path, new_mode).is_err() {
                reply.error(libc::EIO);
                return;
            }
        }

        // Handle chown
        if uid.is_some() || gid.is_some() {
            let new_uid = uid.unwrap_or(u32::MAX);
            let new_gid = gid.unwrap_or(u32::MAX);
            if pool.chown(&path, new_uid, new_gid).is_err() {
                reply.error(libc::EIO);
                return;
            }
        }

        // Handle truncate
        if let Some(new_size) = size {
            if pool.truncate(&path, new_size).is_err() {
                reply.error(libc::EIO);
                return;
            }
        }

        // Return updated attributes
        match pool.stat(&path) {
            Ok(stat) => {
                let attr = to_file_attr(&stat, ino);
                reply.attr(&TTL, &attr);
            }
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Read symbolic link target.
    fn readlink(&mut self, _req: &Request<'_>, ino: u64, reply: ReplyData) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let pool = self.pool.lock().unwrap();
        match pool.readlink(&path) {
            Ok(target) => {
                reply.data(target.as_bytes());
            }
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Create a file node (regular file, device, etc.).
    fn mknod(
        &mut self,
        _req: &Request<'_>,
        parent: u64,
        name: &OsStr,
        mode: u32,
        _umask: u32,
        _rdev: u32,
        reply: ReplyEntry,
    ) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let name_str = name.to_string_lossy();
        let path = Self::join_path(&parent_path, &name_str);

        let mut pool = self.pool.lock().unwrap();
        match pool.create(&path, mode) {
            Ok(fd) => {
                // Close immediately - we just created it
                let _ = pool.close(fd);

                match pool.stat(&path) {
                    Ok(stat) => {
                        let ino = self.get_or_create_inode(&path);
                        let attr = to_file_attr(&stat, ino);
                        reply.entry(&TTL, &attr, 0);
                    }
                    Err(_) => {
                        reply.error(libc::EIO);
                    }
                }
            }
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Create a directory.
    fn mkdir(
        &mut self,
        _req: &Request<'_>,
        parent: u64,
        name: &OsStr,
        mode: u32,
        _umask: u32,
        reply: ReplyEntry,
    ) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let name_str = name.to_string_lossy();
        let path = Self::join_path(&parent_path, &name_str);

        let mut pool = self.pool.lock().unwrap();
        match pool.mkdir(&path, mode) {
            Ok(()) => match pool.stat(&path) {
                Ok(stat) => {
                    let ino = self.get_or_create_inode(&path);
                    let attr = to_file_attr(&stat, ino);
                    reply.entry(&TTL, &attr, 0);
                }
                Err(_) => {
                    reply.error(libc::EIO);
                }
            },
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Remove a file.
    fn unlink(&mut self, _req: &Request<'_>, parent: u64, name: &OsStr, reply: fuser::ReplyEmpty) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let name_str = name.to_string_lossy();
        let path = Self::join_path(&parent_path, &name_str);

        let mut pool = self.pool.lock().unwrap();
        match pool.unlink(&path) {
            Ok(()) => reply.ok(),
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Remove a directory.
    fn rmdir(&mut self, _req: &Request<'_>, parent: u64, name: &OsStr, reply: fuser::ReplyEmpty) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let name_str = name.to_string_lossy();
        let path = Self::join_path(&parent_path, &name_str);

        let mut pool = self.pool.lock().unwrap();
        match pool.rmdir(&path) {
            Ok(()) => reply.ok(),
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Create a symbolic link.
    fn symlink(
        &mut self,
        _req: &Request<'_>,
        parent: u64,
        name: &OsStr,
        link: &std::path::Path,
        reply: ReplyEntry,
    ) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let name_str = name.to_string_lossy();
        let path = Self::join_path(&parent_path, &name_str);
        let target = link.to_string_lossy();

        let mut pool = self.pool.lock().unwrap();
        match pool.symlink(&path, &target) {
            Ok(()) => match pool.stat(&path) {
                Ok(stat) => {
                    let ino = self.get_or_create_inode(&path);
                    let attr = to_file_attr(&stat, ino);
                    reply.entry(&TTL, &attr, 0);
                }
                Err(_) => reply.error(libc::EIO),
            },
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Rename a file or directory.
    fn rename(
        &mut self,
        _req: &Request<'_>,
        parent: u64,
        name: &OsStr,
        newparent: u64,
        newname: &OsStr,
        _flags: u32,
        reply: fuser::ReplyEmpty,
    ) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };
        let Some(newparent_path) = self.get_path(newparent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let old_path = Self::join_path(&parent_path, &name.to_string_lossy());
        let new_path = Self::join_path(&newparent_path, &newname.to_string_lossy());

        let mut pool = self.pool.lock().unwrap();
        match pool.rename(&old_path, &new_path) {
            Ok(()) => reply.ok(),
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Create a hard link.
    fn link(
        &mut self,
        _req: &Request<'_>,
        ino: u64,
        newparent: u64,
        newname: &OsStr,
        reply: ReplyEntry,
    ) {
        let Some(existing_path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };
        let Some(parent_path) = self.get_path(newparent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let new_path = Self::join_path(&parent_path, &newname.to_string_lossy());

        let mut pool = self.pool.lock().unwrap();
        match pool.link(&existing_path, &new_path) {
            Ok(()) => match pool.stat(&new_path) {
                Ok(stat) => {
                    let new_ino = self.get_or_create_inode(&new_path);
                    let attr = to_file_attr(&stat, new_ino);
                    reply.entry(&TTL, &attr, 0);
                }
                Err(_) => reply.error(libc::EIO),
            },
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Open a file.
    fn open(&mut self, _req: &Request<'_>, ino: u64, flags: i32, reply: ReplyOpen) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let mut pool = self.pool.lock().unwrap();
        match pool.open(&path, flags as u32) {
            Ok(fd) => {
                let fh = self.alloc_fh(path, fd);
                reply.opened(fh, 0);
            }
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Read data from a file.
    fn read(
        &mut self,
        _req: &Request<'_>,
        _ino: u64,
        fh: u64,
        offset: i64,
        size: u32,
        _flags: i32,
        _lock_owner: Option<u64>,
        reply: ReplyData,
    ) {
        let Some(fd) = self.get_fd(fh) else {
            reply.error(libc::EBADF);
            return;
        };

        let mut pool = self.pool.lock().unwrap();

        // Seek to offset
        if pool.lseek(fd, offset, 0).is_err() {
            reply.error(libc::EIO);
            return;
        }

        // Read data
        let mut buf = vec![0u8; size as usize];
        match pool.read(fd, &mut buf) {
            Ok(n) => {
                reply.data(&buf[..n]);
            }
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Write data to a file.
    fn write(
        &mut self,
        _req: &Request<'_>,
        _ino: u64,
        fh: u64,
        offset: i64,
        data: &[u8],
        _write_flags: u32,
        _flags: i32,
        _lock_owner: Option<u64>,
        reply: ReplyWrite,
    ) {
        let Some(fd) = self.get_fd(fh) else {
            reply.error(libc::EBADF);
            return;
        };

        let mut pool = self.pool.lock().unwrap();

        // Seek to offset
        if pool.lseek(fd, offset, 0).is_err() {
            reply.error(libc::EIO);
            return;
        }

        // Write data
        match pool.write(fd, data) {
            Ok(n) => {
                reply.written(n as u32);
            }
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Release (close) a file.
    fn release(
        &mut self,
        _req: &Request<'_>,
        _ino: u64,
        fh: u64,
        _flags: i32,
        _lock_owner: Option<u64>,
        _flush: bool,
        reply: fuser::ReplyEmpty,
    ) {
        if let Some((_path, fd)) = self.remove_fh(fh) {
            let mut pool = self.pool.lock().unwrap();
            let _ = pool.close(fd);
        }
        reply.ok();
    }

    /// Synchronize file contents.
    fn fsync(
        &mut self,
        _req: &Request<'_>,
        _ino: u64,
        fh: u64,
        _datasync: bool,
        reply: fuser::ReplyEmpty,
    ) {
        if let Some(fd) = self.get_fd(fh) {
            let mut pool = self.pool.lock().unwrap();
            match pool.fsync(fd) {
                Ok(()) => reply.ok(),
                Err(_) => reply.error(libc::EIO),
            }
        } else {
            reply.error(libc::EBADF);
        }
    }

    /// Open a directory.
    fn opendir(&mut self, _req: &Request<'_>, ino: u64, _flags: i32, reply: ReplyOpen) {
        if self.get_path(ino).is_some() {
            // Directories don't need real handles - use inode as handle
            reply.opened(ino, 0);
        } else {
            reply.error(libc::ENOENT);
        }
    }

    /// Read directory entries.
    fn readdir(
        &mut self,
        _req: &Request<'_>,
        ino: u64,
        _fh: u64,
        offset: i64,
        mut reply: ReplyDirectory,
    ) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let pool = self.pool.lock().unwrap();
        match pool.readdir(&path) {
            Ok(entries) => {
                // Add . and .. first
                let mut all_entries: Vec<(u64, FuseFileType, String)> = vec![
                    (ino, FuseFileType::Directory, ".".to_string()),
                    (ino, FuseFileType::Directory, "..".to_string()), // Simplified: parent = self
                ];

                // Add actual entries
                for entry in entries {
                    let entry_path = Self::join_path(&path, &entry.name);
                    let entry_ino = self.get_or_create_inode(&entry_path);
                    let file_type = to_fuse_file_type(entry.file_type);
                    all_entries.push((entry_ino, file_type, entry.name));
                }

                // Skip to offset and add entries
                for (i, (entry_ino, file_type, name)) in
                    all_entries.iter().enumerate().skip(offset as usize)
                {
                    // reply.add returns true if buffer is full
                    if reply.add(*entry_ino, (i + 1) as i64, *file_type, name) {
                        break;
                    }
                }
                reply.ok();
            }
            Err(_) => {
                reply.error(libc::EIO);
            }
        }
    }

    /// Release (close) a directory.
    fn releasedir(
        &mut self,
        _req: &Request<'_>,
        _ino: u64,
        _fh: u64,
        _flags: i32,
        reply: fuser::ReplyEmpty,
    ) {
        reply.ok();
    }

    /// Get filesystem statistics.
    fn statfs(&mut self, _req: &Request<'_>, _ino: u64, reply: fuser::ReplyStatfs) {
        let pool = self.pool.lock().unwrap();
        if let Ok(stats) = pool.statfs() {
            reply.statfs(
                stats.total_blocks,
                stats.free_blocks,
                stats.available_blocks,
                stats.total_files,
                stats.free_files,
                stats.block_size as u32,
                stats.max_name_len as u32,
                stats.fragment_size as u32,
            );
        } else {
            // Return reasonable defaults
            reply.statfs(
                1_000_000, // blocks
                500_000,   // bfree
                500_000,   // bavail
                1_000_000, // files
                500_000,   // ffree
                4096,      // bsize
                255,       // namelen
                4096,      // frsize
            );
        }
    }

    /// Create and open a file atomically.
    fn create(
        &mut self,
        _req: &Request<'_>,
        parent: u64,
        name: &OsStr,
        mode: u32,
        _umask: u32,
        flags: i32,
        reply: fuser::ReplyCreate,
    ) {
        let Some(parent_path) = self.get_path(parent) else {
            reply.error(libc::ENOENT);
            return;
        };

        let name_str = name.to_string_lossy();
        let path = Self::join_path(&parent_path, &name_str);

        let mut pool = self.pool.lock().unwrap();

        // Create the file
        match pool.create(&path, mode) {
            Ok(fd) => {
                // Close and reopen with requested flags if different
                let _ = pool.close(fd);

                match pool.open(&path, flags as u32) {
                    Ok(fd) => {
                        let fh = self.alloc_fh(path.clone(), fd);

                        match pool.stat(&path) {
                            Ok(stat) => {
                                let ino = self.get_or_create_inode(&path);
                                let attr = to_file_attr(&stat, ino);
                                reply.created(&TTL, &attr, 0, fh, 0);
                            }
                            Err(_) => reply.error(libc::EIO),
                        }
                    }
                    Err(_) => reply.error(libc::EIO),
                }
            }
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Get extended attribute.
    fn getxattr(
        &mut self,
        _req: &Request<'_>,
        ino: u64,
        name: &OsStr,
        size: u32,
        reply: fuser::ReplyXattr,
    ) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let pool = self.pool.lock().unwrap();
        let name_str = name.to_string_lossy();

        match pool.getxattr(&path, &name_str) {
            Ok(value) => {
                if size == 0 {
                    reply.size(value.len() as u32);
                } else if size < value.len() as u32 {
                    reply.error(libc::ERANGE);
                } else {
                    reply.data(&value);
                }
            }
            Err(_) => reply.error(libc::ENODATA),
        }
    }

    /// Set extended attribute.
    fn setxattr(
        &mut self,
        _req: &Request<'_>,
        ino: u64,
        name: &OsStr,
        value: &[u8],
        _flags: i32,
        _position: u32,
        reply: fuser::ReplyEmpty,
    ) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let mut pool = self.pool.lock().unwrap();
        let name_str = name.to_string_lossy();

        match pool.setxattr(&path, &name_str, value) {
            Ok(()) => reply.ok(),
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// List extended attributes.
    fn listxattr(&mut self, _req: &Request<'_>, ino: u64, size: u32, reply: fuser::ReplyXattr) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let pool = self.pool.lock().unwrap();
        match pool.listxattr(&path) {
            Ok(names) => {
                // Build null-terminated list
                let mut data = Vec::new();
                for name in names {
                    data.extend_from_slice(name.as_bytes());
                    data.push(0);
                }

                if size == 0 {
                    reply.size(data.len() as u32);
                } else if size < data.len() as u32 {
                    reply.error(libc::ERANGE);
                } else {
                    reply.data(&data);
                }
            }
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Remove extended attribute.
    fn removexattr(
        &mut self,
        _req: &Request<'_>,
        ino: u64,
        name: &OsStr,
        reply: fuser::ReplyEmpty,
    ) {
        let Some(path) = self.get_path(ino) else {
            reply.error(libc::ENOENT);
            return;
        };

        let mut pool = self.pool.lock().unwrap();
        let name_str = name.to_string_lossy();

        match pool.removexattr(&path, &name_str) {
            Ok(()) => reply.ok(),
            Err(_) => reply.error(libc::EIO),
        }
    }

    /// Check file access permissions.
    fn access(&mut self, _req: &Request<'_>, ino: u64, _mask: i32, reply: fuser::ReplyEmpty) {
        // Simplified: if we can stat it, we can access it
        if self.get_path(ino).is_some() {
            reply.ok();
        } else {
            reply.error(libc::ENOENT);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_join_path() {
        assert_eq!(LcpfsFuse::join_path("/", "foo"), "/foo");
        assert_eq!(LcpfsFuse::join_path("/home", "user"), "/home/user");
        assert_eq!(LcpfsFuse::join_path("/a/b", "c"), "/a/b/c");
    }
}