ex_cli/

printer.rs

use crate::config::{Config, ExecKind, FileKind, RecentKind};
use crate::error::MyResult;
use crate::fs::file::{File, Signature};
use crate::fs::total::Total;
use crate::regex;
use crate::util::calendar::Calendar;
use crate::util::colors::ColorMap;
use chrono::*;
#[cfg(windows)]
use regex::Captures;
use std::collections::HashMap;
use std::ffi::OsStr;
use std::path::{Component, Path, PathBuf};
#[cfg(unix)]
use std::rc::Rc;
use std::{cmp, path};
use termcolor::WriteColor;

const MODE_WIDTH: usize = 10; // (width of "drwxrwxrwx")
const TIME_WIDTH: usize = 20; // (width of "31-Dec-2023 23:59:59")
const MONTH_WIDTH: usize = 8; // (width of "12 month")
const SIG_WIDTH: usize = 13; // (width of "41424344 ABCD")
const PAD_WIDTH: usize = 2; // (width of "  ")

pub struct IndentChars {
    pub branching: char,
    pub terminating: char,
    pub horizontal: char,
    pub vertical: char,
}

enum IndentToken {
    BranchMiddle,
    BranchFinal,
    SpaceMiddle,
    SpaceFinal,
}

#[allow(dead_code)]
pub struct Printer<'a, W: WriteColor> {
    config: &'a Config,
    calendar: Calendar,
    writer: W,
    counter: HashMap<PathBuf, isize>,
    colors: ColorMap,
    chars: IndentChars,
    git_bash: bool,
    separator: char,
    separator_str: String,
}

impl<'a, W: WriteColor> Printer<'a, W> {
    pub fn new<Tz: TimeZone>(
        config: &'a Config,
        zone: &Tz,
        writer: W,
        colors: ColorMap,
        chars: IndentChars,
        git_bash: bool,
    ) -> Self {
        let calendar = Calendar::from_time(&config.curr_time, zone);
        let counter = HashMap::new();
        #[cfg(windows)]
        let git_bash = git_bash && !config.win_path;
        let separator = if git_bash { '/' } else { path::MAIN_SEPARATOR };
        let separator_str = separator.to_string();
        Self {
            config,
            calendar,
            writer,
            counter,
            colors,
            chars,
            git_bash,
            separator,
            separator_str,
        }
    }

    pub fn print_files<Tz: TimeZone>(
        &mut self,
        files: &Vec<File>,
        total: &Total,
        zone: &Tz,
    ) -> MyResult<()> {
        if self.config.show_indent {
            self.count_parents(files);
        }
        if self.config.only_path {
            for file in files {
                self.print_path(file)?;
                self.print_newline()?;
            }
        } else {
            let mode_width = measure_mode(self.config);
            let size_width = if self.config.show_total {
                measure_size(self.config, total.total_size)
            } else {
                measure_size(self.config, total.max_size)
            };
            let time_width = measure_time(self.config);
            if self.config.filter_recent != RecentKind::None {
                self.print_start(total, zone, mode_width, size_width, time_width)?;
            }
            for file in files {
                self.print_file(file, total, zone, size_width)?;
            }
            if self.config.show_total {
                self.print_total(total, mode_width, size_width, time_width)?;
            }
        }
        Ok(())
    }

    #[allow(unused_mut)]
    fn print_start<Tz: TimeZone>(
        &mut self,
        total: &Total,
        zone: &Tz,
        mode_width: usize,
        size_width: usize,
        time_width: usize,
    ) -> MyResult<()> {
        if let Some(start_time) = &total.start_time {
            let mut combined_width = mode_width + PAD_WIDTH + size_width + PAD_WIDTH;
            #[cfg(unix)]
            if self.config.show_owner {
                combined_width += total.user_width + 1 + total.group_width + PAD_WIDTH;
            }
            self.print_text("Start", combined_width)?;
            self.print_time(start_time, zone, false)?;
            writeln!(self.writer)?;
            self.print_hyphens(combined_width + time_width)?;
        }
        Ok(())
    }

    fn print_file<Tz: TimeZone>(
        &mut self,
        file: &File,
        total: &Total,
        zone: &Tz,
        size_width: usize,
    ) -> MyResult<()> {
        self.print_mode(file.file_type, file.file_mode, file.zip_depth)?;
        #[cfg(unix)]
        self.print_owner(&file.owner_user, &file.owner_group, total.user_width, total.group_width)?;
        self.print_size(file.file_size, size_width)?;
        self.print_time(&file.file_time, zone, true)?;
        self.print_sig(file.file_sig)?;
        #[cfg(windows)]
        self.print_version(&file.file_ver, total.ver_width)?;
        self.print_ext(&file.file_ext, total.ext_width)?;
        #[cfg(debug_assertions)]
        self.print_debug(file.file_depth, file.zip_depth)?;
        self.print_path(file)?;
        writeln!(self.writer)?;
        Ok(())
    }

    #[allow(unused_mut)]
    fn print_total(
        &mut self,
        total: &Total,
        mode_width: usize,
        size_width: usize,
        time_width: usize,
    ) -> MyResult<()> {
        let mut combined_width = mode_width + PAD_WIDTH;
        #[cfg(unix)]
        if self.config.show_owner {
            combined_width += total.user_width + 1 + total.group_width + PAD_WIDTH;
        }
        self.print_hyphens(combined_width + size_width + PAD_WIDTH + time_width)?;
        self.print_text("Total", combined_width)?;
        self.print_size(total.total_size, size_width)?;
        self.print_spaces(time_width + PAD_WIDTH)?;
        if self.config.show_sig {
            self.print_spaces(SIG_WIDTH + PAD_WIDTH)?;
        }
        if total.ext_width > 0 {
            self.print_spaces(total.ext_width + PAD_WIDTH)?;
        }
        self.print_summary(total)?;
        writeln!(self.writer)?;
        Ok(())
    }

    fn print_summary(
        &mut self,
        total: &Total,
    ) -> MyResult<()> {
        let files = if total.num_files == 1 { "file" } else { "files" };
        let dirs = if total.num_dirs == 1 { "directory" } else { "directories" };
        write!(
            self.writer,
            "{num_files} {files} {num_dirs} {dirs}",
            num_files = total.num_files,
            num_dirs = total.num_dirs,
        )?;
        Ok(())
    }

    fn print_mode(
        &mut self,
        file_type: FileKind,
        file_mode: u32,
        zip_depth: Option<usize>,
    ) -> MyResult<()> {
        if self.config.zip_expand {
            if zip_depth.is_some() {
                write!(self.writer, "z")?;
            } else {
                write!(self.writer, "-")?;
            }
        }
        match file_type {
            FileKind::File(_) => write!(self.writer, "-")?,
            FileKind::Dir => write!(self.writer, "d")?,
            FileKind::Link(_) => write!(self.writer, "l")?,
            FileKind::Other => write!(self.writer, "?")?,
        };
        for shift in [6, 3, 0] {
            let file_mode = file_mode >> shift;
            if (file_mode & 4) != 0 {
                write!(self.writer, "r")?;
            } else {
                write!(self.writer, "-")?;
            }
            if (file_mode & 2) != 0 {
                write!(self.writer, "w")?;
            } else {
                write!(self.writer, "-")?;
            }
            if (file_mode & 1) != 0 {
                write!(self.writer, "x")?;
            } else {
                write!(self.writer, "-")?;
            }
        }
        self.print_spaces(PAD_WIDTH)?;
        Ok(())
    }

    #[cfg(unix)]
    fn print_owner(
        &mut self,
        owner_user: &Option<Rc<String>>,
        owner_group: &Option<Rc<String>>,
        user_width: usize,
        group_width: usize,
    ) -> MyResult<()> {
        if self.config.show_owner {
            if let Some(user) = owner_user {
                write!(self.writer, "{0:1$}", user, user_width + 1)?;
            } else {
                write!(self.writer, "{0:1$}", "-", user_width + 1)?;
            }
            if let Some(group) = owner_group {
                write!(self.writer, "{0:1$}", group, group_width + PAD_WIDTH)?;
            } else {
                write!(self.writer, "{0:1$}", "-", group_width + PAD_WIDTH)?;
            }
        }
        Ok(())
    }

    fn print_size(
        &mut self,
        file_size: u64,
        size_width: usize,
    ) -> MyResult<()> {
        if self.config.show_pretty {
            if file_size < 1_000 {
                write!(self.writer, "{0:3} B ", file_size)?;
            } else if file_size < 1_000_000 {
                write!(self.writer, "{0:3} KB", file_size / 1_000)?;
            } else if file_size < 1_000_000_000 {
                write!(self.writer, "{0:3} MB", file_size / 1_000_000)?;
            } else if file_size < 1_000_000_000_000 {
                write!(self.writer, "{0:3} GB", file_size / 1_000_000_000)?;
            } else if file_size < 1_000_000_000_000_000 {
                write!(self.writer, "{0:3} TB", file_size / 1_000_000_000_000)?;
            } else if file_size < 1_000_000_000_000_000_000 {
                write!(self.writer, "{0:3} PB", file_size / 1_000_000_000_000_000)?;
            } else {
                write!(self.writer, "{0:3} EB", file_size / 1_000_000_000_000_000_000)?;
            }
        } else {
            self.print_thousand(file_size, size_width)?;
        }
        self.print_spaces(PAD_WIDTH)?;
        Ok(())
    }

    fn print_thousand(
        &mut self,
        file_size: u64,
        size_width: usize,
    ) -> MyResult<()> {
        if file_size < 1000 {
            write!(self.writer, "{0:1$}", file_size, size_width)?;
        } else {
            self.print_thousand(file_size / 1000, cmp::max(size_width, 4) - 4)?;
            write!(self.writer, ",{0:03}", file_size % 1000)?;
        }
        Ok(())
    }

    fn print_time<Tz: TimeZone>(
        &mut self,
        file_time: &DateTime<Utc>,
        zone: &Tz,
        padding: bool,
    ) -> MyResult<()> {
        if self.config.show_pretty {
            if file_time.timestamp() != 0 {
                let recent = RecentKind::from_times(&file_time, &self.config.curr_time, &self.calendar, zone);
                match recent {
                    RecentKind::None => write!(self.writer, " future")?,
                    RecentKind::Sec(count) => write!(self.writer, "{:2} sec", count)?,
                    RecentKind::Min(count) => write!(self.writer, "{:2} min", count)?,
                    RecentKind::Hour(count) => write!(self.writer, "{:2} hour", count)?,
                    RecentKind::Day(count) => write!(self.writer, "{:2} day", count)?,
                    RecentKind::Week(count) => write!(self.writer, "{:2} week", count)?,
                    RecentKind::Month(count) => write!(self.writer, "{:2} month", count)?,
                    RecentKind::Year(count) => write!(self.writer, "{:2} year", count)?,
                }
                if padding {
                    match recent {
                        RecentKind::None => write!(self.writer, " ")?,
                        RecentKind::Sec(_) => write!(self.writer, "  ")?,
                        RecentKind::Min(_) => write!(self.writer, "  ")?,
                        RecentKind::Hour(_) => write!(self.writer, " ")?,
                        RecentKind::Day(_) => write!(self.writer, "  ")?,
                        RecentKind::Week(_) => write!(self.writer, " ")?,
                        RecentKind::Month(_) => (),
                        RecentKind::Year(_) => write!(self.writer, " ")?,
                    }
                }
            } else {
                write!(self.writer, "{0:-<1$}", "", MONTH_WIDTH)?;
            }
        } else {
            if file_time.timestamp() != 0 {
                let file_time = file_time.with_timezone(zone);
                let day = file_time.day();
                let month = convert_month(file_time.month());
                let year = file_time.year();
                let hour = file_time.hour();
                let minute = file_time.minute();
                let second = file_time.second();
                write!(self.writer, "{day:02}-{month}-{year:04} {hour:02}:{minute:02}:{second:02}")?;
                if self.config.show_utc {
                    write!(self.writer, "Z")?;
                }
            } else {
                write!(self.writer, "{0:-<1$}", "", TIME_WIDTH)?;
                if self.config.show_utc {
                    write!(self.writer, "-")?;
                }
            }
        }
        if padding {
            self.print_spaces(PAD_WIDTH)?;
        }
        Ok(())
    }

    fn print_sig(&mut self, file_sig: Signature) -> MyResult<()> {
        if self.config.show_sig {
            for byte in file_sig {
                write!(self.writer, "{:02x}", byte)?;
            }
            write!(self.writer, " ")?;
            for byte in file_sig {
                write!(self.writer, "{}", printable_char(byte))?;
            }
            self.print_spaces(PAD_WIDTH)?;
        }
        Ok(())
    }

    #[cfg(windows)]
    fn print_version(
        &mut self,
        file_ver: &Option<String>,
        ver_width: usize,
    ) -> MyResult<()> {
        if ver_width > 0 {
            if let Some(file_ver) = file_ver {
                write!(self.writer, "{0:1$}", file_ver, ver_width)?;
                self.print_spaces(PAD_WIDTH)?;
            } else {
                self.print_spaces(ver_width + PAD_WIDTH)?;
            }
        }
        Ok(())
    }

    fn print_ext(
        &mut self,
        file_ext: &str,
        ext_width: usize,
    ) -> MyResult<()> {
        if ext_width > 0 {
            write!(self.writer, "{0:1$}", file_ext, ext_width)?;
            self.print_spaces(PAD_WIDTH)?;
        }
        Ok(())
    }

    #[cfg(debug_assertions)]
    fn print_debug(
        &mut self,
        file_depth: usize,
        zip_depth: Option<usize>,
    ) -> MyResult<()> {
        if self.config.show_debug {
            self.writer.set_color(&self.colors.debug_color)?;
            if self.config.zip_expand {
                let zip_depth = zip_depth
                    .map(|depth| depth.to_string())
                    .unwrap_or_else(|| "-".to_string());
                write!(self.writer, "[{}][{}]", file_depth, zip_depth)?;
            } else {
                write!(self.writer, "[{}]", file_depth)?;
            }
            self.writer.reset()?;
            write!(self.writer, " ")?;
        }
        Ok(())
    }

    fn print_path(
        &mut self,
        file: &File,
    ) -> MyResult<()> {
        if self.config.show_indent {
            self.print_prefix(file)?;
            if file.file_type == FileKind::Dir {
                self.indent_dir(&file.rel_dir, file.zip_depth, file.file_type.dir_offset())?;
            } else {
                self.print_name(&file.file_name, &file.file_ext, file.file_type)?;
            }
            self.print_link(&file.link_data)?;
        } else {
            let file_dir = file.select_dir(self.config.abs_path);
            if self.config.order_name {
                self.print_name(&file.file_name, &file.file_ext, file.file_type)?;
                self.print_dir(file_dir, file.zip_depth, file.file_type.dir_offset(), true)?;
                self.print_link(&file.link_data)?;
            } else {
                self.print_dir(file_dir, file.zip_depth, file.file_type.dir_offset(), false)?;
                self.print_name(&file.file_name, &file.file_ext, file.file_type)?;
                if !self.config.escape_path && !self.config.null_path {
                    self.print_link(&file.link_data)?;
                }
            }
        }
        Ok(())
    }

    fn print_dir(
        &mut self,
        file_dir: &Path,
        zip_depth: Option<usize>,
        zip_offset: usize,
        order_name: bool,
    ) -> MyResult<()> {
        if !is_trivial(file_dir) {
            if order_name {
                write!(self.writer, " (")?;
                self.iterate_dir(file_dir, zip_depth, zip_offset)?;
                write!(self.writer, ")")?;
            } else {
                self.iterate_dir(file_dir, zip_depth, zip_offset)?;
            }
        }
        Ok(())
    }

    fn iterate_dir(
        &mut self,
        file_dir: &Path,
        zip_depth: Option<usize>,
        zip_offset: usize,
    ) -> MyResult<()> {
        self.writer.set_color(&self.colors.dir_color)?;
        let components = file_dir.components().into_iter().collect::<Vec<_>>();
        let count = components.len();
        for (index, component) in components.iter().enumerate() {
            if let Some(text) = component.as_os_str().to_str() {
                let color = zip_depth
                    .is_some_and(|depth| depth + zip_offset + index == count)
                    .then(|| get_extension(component))
                    .and_then(|ext| self.colors.find_color(ext));
                if let Some(color) = color {
                    self.writer.set_color(color)?;
                    self.escape_dir(text)?;
                    self.writer.set_color(&self.colors.dir_color)?;
                } else {
                    self.escape_dir(text)?;
                }
                if is_joinable(&component) {
                    write!(self.writer, "{}", self.separator)?;
                }
            }
        }
        self.writer.reset()?;
        Ok(())
    }

    fn indent_dir(
        &mut self,
        file_dir: &Path,
        zip_depth: Option<usize>,
        zip_offset: usize,
    ) -> MyResult<()> {
        if let Some(component) = file_dir.components().last() {
            if let Some(text) = component.as_os_str().to_str() {
                let color = zip_depth
                    .is_some_and(|depth| depth + zip_offset == 1)
                    .then(|| get_extension(&component))
                    .and_then(|ext| self.colors.find_color(ext))
                    .unwrap_or(&self.colors.dir_color);
                self.writer.set_color(color)?;
                self.escape_dir(text)?;
                self.writer.reset()?;
            }
        }
        Ok(())
    }

    #[cfg(windows)]
    fn escape_dir(
        &mut self,
        file_dir: &str,
    ) -> MyResult<()> {
        if self.git_bash {
            let drive_regex = regex!(r#"^([A-Z]):(.*)$"#);
            let file_dir = file_dir.replace(path::MAIN_SEPARATOR, &self.separator_str);
            let file_dir = drive_regex.replace(&file_dir, |caps: &Captures| {
                format!("{}{}{}", self.separator, &caps[1].to_lowercase(), &caps[2])
            });
            if self.config.escape_path {
                let escape_regex = regex!(r#"([\s"'])"#);
                let file_dir = escape_regex.replace_all(&file_dir, "\\$1");
                write!(self.writer, "{file_dir}")?;
            } else {
                write!(self.writer, "{file_dir}")?;
            }
        } else {
            write!(self.writer, "{file_dir}")?;
        }
        Ok(())
    }

    #[cfg(not(windows))]
    fn escape_dir(
        &mut self,
        file_dir: &str,
    ) -> MyResult<()> {
        if self.config.escape_path {
            let escape_regex = regex!(r#"([\s"'\\])"#);
            let file_dir = escape_regex.replace_all(file_dir, "\\$1");
            write!(self.writer, "{file_dir}")?;
        } else {
            write!(self.writer, "{file_dir}")?;
        }
        Ok(())
    }

    fn print_name(
        &mut self,
        file_name: &str,
        file_ext: &str,
        file_type: FileKind,
    ) -> MyResult<()> {
        if !file_name.is_empty() {
            match file_type {
                FileKind::File(exec) => {
                    if exec == ExecKind::User {
                        self.writer.set_color(&self.colors.exec_color)?;
                        self.escape_name(file_name)?;
                        self.writer.reset()?;
                    } else if exec == ExecKind::Other {
                        self.writer.set_color(&self.colors.exec_other)?;
                        self.escape_name(file_name)?;
                        self.writer.reset()?;
                    } else if let Some(color) = self.colors.find_color(file_ext) {
                        self.writer.set_color(color)?;
                        self.escape_name(file_name)?;
                        self.writer.reset()?;
                    } else {
                        self.escape_name(file_name)?;
                    }
                }
                FileKind::Dir => {
                    self.writer.set_color(&self.colors.dir_color)?;
                    self.escape_name(file_name)?;
                    write!(self.writer, "{}", self.separator)?;
                    self.writer.reset()?;
                }
                FileKind::Link(resolved) => {
                    if resolved {
                        self.writer.set_color(&self.colors.link_color)?;
                    } else {
                        self.writer.set_color(&self.colors.bad_color)?;
                    }
                    self.escape_name(file_name)?;
                    self.writer.reset()?;
                }
                FileKind::Other => {
                    self.escape_name(file_name)?;
                }
            }
        }
        Ok(())
    }

    #[cfg(windows)]
    fn escape_name(
        &mut self,
        file_name: &str,
    ) -> MyResult<()> {
        if self.config.escape_path && self.git_bash {
            let escape_regex = regex!(r#"([\s"'])"#);
            let file_name = escape_regex.replace_all(file_name, "\\$1");
            write!(self.writer, "{file_name}")?;
        } else {
            write!(self.writer, "{file_name}")?;
        }
        Ok(())
    }

    #[cfg(not(windows))]
    fn escape_name(
        &mut self,
        file_name: &str,
    ) -> MyResult<()> {
        if self.config.escape_path {
            let escape_regex = regex!(r#"([\s"'\\])"#);
            let file_name = escape_regex.replace_all(file_name, "\\$1");
            write!(self.writer, "{file_name}")?;
        } else {
            write!(self.writer, "{file_name}")?;
        }
        Ok(())
    }

    fn print_link(
        &mut self,
        link_data: &Option<(PathBuf, FileKind)>,
    ) -> MyResult<()> {
        if let Some((link_path, link_type)) = link_data {
            if let Some(link_dir) = link_path.parent() {
                if let Some(link_name) = link_path.file_name().and_then(OsStr::to_str) {
                    write!(self.writer, " -> ")?;
                    let link_ext = link_path.extension().and_then(OsStr::to_str).unwrap_or_default();
                    self.print_dir(link_dir, None, 0, false)?;
                    self.print_name(link_name, &link_ext, *link_type)?;
                }
            }
        }
        Ok(())
    }

    fn count_parents(&mut self, files: &Vec<File>) {
        for file in files {
            if file.file_depth > 1 {
                if let Some(parent) = file.select_parent_for_indent() {
                    let entry = self.counter.entry(parent).or_insert(0);
                    *entry += 1;
                }
            }
        }
    }

    fn print_prefix(&mut self, file: &File) -> MyResult<()> {
        let tokens = self.create_prefix(file);
        for token in tokens {
            match token {
                IndentToken::BranchMiddle => {
                    write!(self.writer, " ")?;
                    self.writer.set_color(&self.colors.dir_color)?;
                    write!(self.writer, "{}", self.chars.branching)?;
                    write!(self.writer, "{}", self.chars.horizontal)?;
                    self.writer.reset()?;
                    write!(self.writer, " ")?;
                }
                IndentToken::BranchFinal => {
                    write!(self.writer, " ")?;
                    self.writer.set_color(&self.colors.dir_color)?;
                    write!(self.writer, "{}", self.chars.terminating)?;
                    write!(self.writer, "{}", self.chars.horizontal)?;
                    self.writer.reset()?;
                    write!(self.writer, " ")?;
                }
                IndentToken::SpaceMiddle => {
                    write!(self.writer, " ")?;
                    self.writer.set_color(&self.colors.dir_color)?;
                    write!(self.writer, "{}", self.chars.vertical)?;
                    self.writer.reset()?;
                    write!(self.writer, "  ")?;
                }
                IndentToken::SpaceFinal => {
                    write!(self.writer, "    ")?;
                }
            }
        }
        Ok(())
    }

    fn create_prefix(&mut self, file: &File) -> Vec<IndentToken> {
        let mut tokens = Vec::new();
        if let Some(mut path) = file.select_parent_for_indent() {
            if let Some(count) = self.counter.get_mut(&path) {
                *count -= 1;
                if *count > 0 {
                    tokens.push(IndentToken::BranchMiddle);
                } else {
                    tokens.push(IndentToken::BranchFinal);
                }
            }
            while let Some(parent) = path.parent() {
                path = PathBuf::from(parent);
                if let Some(count) = self.counter.get(&path) {
                    if *count > 0 {
                        tokens.push(IndentToken::SpaceMiddle);
                    } else {
                        tokens.push(IndentToken::SpaceFinal);
                    }
                }
            }
        }
        tokens.reverse();
        tokens
    }

    fn print_text(&mut self, text: &str, width: usize) -> MyResult<()> {
        write!(self.writer, "{0:<1$}", text, width)?;
        Ok(())
    }

    fn print_spaces(&mut self, width: usize) -> MyResult<()> {
        write!(self.writer, "{0:<1$}", "", width)?;
        Ok(())
    }

    fn print_hyphens(&mut self, width: usize) -> MyResult<()> {
        writeln!(self.writer, "{0:-<1$}", "", width)?;
        Ok(())
    }

    fn print_newline(&mut self) -> MyResult<()> {
        if self.config.null_path {
            write!(self.writer, "\x00")?;
        } else {
            writeln!(self.writer)?;
        }
        Ok(())
    }
}

fn measure_mode(config: &Config) -> usize {
    if config.zip_expand {
        MODE_WIDTH + 1
    } else {
        MODE_WIDTH
    }
}

fn measure_size(config: &Config, size: u64) -> usize {
    if config.show_pretty {
        6
    } else {
        recurse_size(size)
    }
}

fn recurse_size(size: u64) -> usize {
    if size < 1000 {
        3
    } else {
        recurse_size(size / 1000) + 4
    }
}

fn measure_time(config: &Config) -> usize {
    if config.show_pretty {
        MONTH_WIDTH
    } else if config.show_utc {
        TIME_WIDTH + 1 // (with extra "Z")
    } else {
        TIME_WIDTH
    }
}

fn convert_month(month: u32) -> &'static str {
    match month {
        1 => "Jan",
        2 => "Feb",
        3 => "Mar",
        4 => "Apr",
        5 => "May",
        6 => "Jun",
        7 => "Jul",
        8 => "Aug",
        9 => "Sep",
        10 => "Oct",
        11 => "Nov",
        12 => "Dec",
        _ => "???",
    }
}

#[inline]
fn printable_char(byte: u8) -> char {
    if byte >= 32 && byte <= 126 { byte as char } else { '.' }
}

fn is_trivial(file_dir: &Path) -> bool {
    let file_dir = file_dir.to_str().unwrap_or_default();
    file_dir.is_empty() || file_dir == "."
}

fn is_joinable(component: &Component) -> bool {
    match component {
        Component::Prefix(_) => false,
        Component::RootDir => false,
        Component::CurDir => true,
        Component::ParentDir => true,
        Component::Normal(_) => true,
    }
}

fn get_extension<'a>(component: &'a Component) -> &'a str {
    let component = component.as_os_str();
    let (_, ext) = rsplit_file_at_dot(component);
    ext.and_then(OsStr::to_str).unwrap_or_default()
}

// Borrowed from standard library.
fn rsplit_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {
    if file.as_encoded_bytes() == b".." {
        (Some(file), None)
    } else {
        // The unsafety here stems from converting between &OsStr and &[u8]
        // and back. This is safe to do because (1) we only look at ASCII
        // contents of the encoding and (2) new &OsStr values are produced
        // only from ASCII-bounded slices of existing &OsStr values.
        let mut iter = file.as_encoded_bytes().rsplitn(2, |b| *b == b'.');
        let after = iter.next();
        let before = iter.next();
        if before == Some(b"") {
            (Some(file), None)
        } else {
            unsafe {
                let before = before.map(|s| OsStr::from_encoded_bytes_unchecked(s));
                let after = after.map(|s| OsStr::from_encoded_bytes_unchecked(s));
                (before, after)
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::RecentKind;
    use path_clean::PathClean;
    use pretty_assertions::assert_eq;
    use std::cmp::Ordering;
    use std::io;
    use std::io::Write;
    use std::path::PathBuf;
    use termcolor::{Color, ColorSpec};

    #[test]
    fn test_measures_mode_no_expand() {
        let config = Config::default()
            .with_zip_expand(false);
        assert_eq!(10, measure_mode(&config));
    }

    #[test]
    fn test_measures_mode_with_expand() {
        let config = Config::default()
            .with_zip_expand(true);
        assert_eq!(11, measure_mode(&config));
    }

    #[test]
    fn test_prints_type_no_expand() {
        assert_eq!("----------  ", wrap_mode(false, None, 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("----------  ", wrap_mode(false, None, 0o000, FileKind::File(ExecKind::User)));
        assert_eq!("----------  ", wrap_mode(false, None, 0o000, FileKind::File(ExecKind::Other)));
        assert_eq!("d---------  ", wrap_mode(false, None, 0o000, FileKind::Dir));
        assert_eq!("l---------  ", wrap_mode(false, None, 0o000, FileKind::Link(false)));
        assert_eq!("l---------  ", wrap_mode(false, None, 0o000, FileKind::Link(true)));
        assert_eq!("?---------  ", wrap_mode(false, None, 0o000, FileKind::Other));
        assert_eq!("----------  ", wrap_mode(false, Some(0), 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("----------  ", wrap_mode(false, Some(0), 0o000, FileKind::File(ExecKind::User)));
        assert_eq!("----------  ", wrap_mode(false, Some(0), 0o000, FileKind::File(ExecKind::Other)));
        assert_eq!("d---------  ", wrap_mode(false, Some(0), 0o000, FileKind::Dir));
        assert_eq!("l---------  ", wrap_mode(false, Some(0), 0o000, FileKind::Link(false)));
        assert_eq!("l---------  ", wrap_mode(false, Some(0), 0o000, FileKind::Link(true)));
        assert_eq!("?---------  ", wrap_mode(false, Some(0), 0o000, FileKind::Other));
    }

    #[test]
    fn test_prints_type_with_expand() {
        assert_eq!("-----------  ", wrap_mode(true, None, 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("-----------  ", wrap_mode(true, None, 0o000, FileKind::File(ExecKind::User)));
        assert_eq!("-----------  ", wrap_mode(true, None, 0o000, FileKind::File(ExecKind::Other)));
        assert_eq!("-d---------  ", wrap_mode(true, None, 0o000, FileKind::Dir));
        assert_eq!("-l---------  ", wrap_mode(true, None, 0o000, FileKind::Link(false)));
        assert_eq!("-l---------  ", wrap_mode(true, None, 0o000, FileKind::Link(true)));
        assert_eq!("-?---------  ", wrap_mode(true, None, 0o000, FileKind::Other));
        assert_eq!("z----------  ", wrap_mode(true, Some(0), 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("z----------  ", wrap_mode(true, Some(0), 0o000, FileKind::File(ExecKind::User)));
        assert_eq!("z----------  ", wrap_mode(true, Some(0), 0o000, FileKind::File(ExecKind::Other)));
        assert_eq!("zd---------  ", wrap_mode(true, Some(0), 0o000, FileKind::Dir));
        assert_eq!("zl---------  ", wrap_mode(true, Some(0), 0o000, FileKind::Link(false)));
        assert_eq!("zl---------  ", wrap_mode(true, Some(0), 0o000, FileKind::Link(true)));
        assert_eq!("z?---------  ", wrap_mode(true, Some(0), 0o000, FileKind::Other));
    }

    #[test]
    fn test_prints_mode_no_expand() {
        assert_eq!("----------  ", wrap_mode(false, None, 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("-r--------  ", wrap_mode(false, None, 0o400, FileKind::File(ExecKind::None)));
        assert_eq!("--w-------  ", wrap_mode(false, None, 0o200, FileKind::File(ExecKind::None)));
        assert_eq!("---x------  ", wrap_mode(false, None, 0o100, FileKind::File(ExecKind::None)));
        assert_eq!("----r-----  ", wrap_mode(false, None, 0o040, FileKind::File(ExecKind::None)));
        assert_eq!("-----w----  ", wrap_mode(false, None, 0o020, FileKind::File(ExecKind::None)));
        assert_eq!("------x---  ", wrap_mode(false, None, 0o010, FileKind::File(ExecKind::None)));
        assert_eq!("-------r--  ", wrap_mode(false, None, 0o004, FileKind::File(ExecKind::None)));
        assert_eq!("--------w-  ", wrap_mode(false, None, 0o002, FileKind::File(ExecKind::None)));
        assert_eq!("---------x  ", wrap_mode(false, None, 0o001, FileKind::File(ExecKind::None)));
        assert_eq!("-rwxrwxrwx  ", wrap_mode(false, None, 0o777, FileKind::File(ExecKind::None)));
        assert_eq!("----------  ", wrap_mode(false, Some(0), 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("-r--------  ", wrap_mode(false, Some(0), 0o400, FileKind::File(ExecKind::None)));
        assert_eq!("--w-------  ", wrap_mode(false, Some(0), 0o200, FileKind::File(ExecKind::None)));
        assert_eq!("---x------  ", wrap_mode(false, Some(0), 0o100, FileKind::File(ExecKind::None)));
        assert_eq!("----r-----  ", wrap_mode(false, Some(0), 0o040, FileKind::File(ExecKind::None)));
        assert_eq!("-----w----  ", wrap_mode(false, Some(0), 0o020, FileKind::File(ExecKind::None)));
        assert_eq!("------x---  ", wrap_mode(false, Some(0), 0o010, FileKind::File(ExecKind::None)));
        assert_eq!("-------r--  ", wrap_mode(false, Some(0), 0o004, FileKind::File(ExecKind::None)));
        assert_eq!("--------w-  ", wrap_mode(false, Some(0), 0o002, FileKind::File(ExecKind::None)));
        assert_eq!("---------x  ", wrap_mode(false, Some(0), 0o001, FileKind::File(ExecKind::None)));
        assert_eq!("-rwxrwxrwx  ", wrap_mode(false, Some(0), 0o777, FileKind::File(ExecKind::None)));
    }

    #[test]
    fn test_prints_mode_with_expand() {
        assert_eq!("-----------  ", wrap_mode(true, None, 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("--r--------  ", wrap_mode(true, None, 0o400, FileKind::File(ExecKind::None)));
        assert_eq!("---w-------  ", wrap_mode(true, None, 0o200, FileKind::File(ExecKind::None)));
        assert_eq!("----x------  ", wrap_mode(true, None, 0o100, FileKind::File(ExecKind::None)));
        assert_eq!("-----r-----  ", wrap_mode(true, None, 0o040, FileKind::File(ExecKind::None)));
        assert_eq!("------w----  ", wrap_mode(true, None, 0o020, FileKind::File(ExecKind::None)));
        assert_eq!("-------x---  ", wrap_mode(true, None, 0o010, FileKind::File(ExecKind::None)));
        assert_eq!("--------r--  ", wrap_mode(true, None, 0o004, FileKind::File(ExecKind::None)));
        assert_eq!("---------w-  ", wrap_mode(true, None, 0o002, FileKind::File(ExecKind::None)));
        assert_eq!("----------x  ", wrap_mode(true, None, 0o001, FileKind::File(ExecKind::None)));
        assert_eq!("--rwxrwxrwx  ", wrap_mode(true, None, 0o777, FileKind::File(ExecKind::None)));
        assert_eq!("z----------  ", wrap_mode(true, Some(0), 0o000, FileKind::File(ExecKind::None)));
        assert_eq!("z-r--------  ", wrap_mode(true, Some(0), 0o400, FileKind::File(ExecKind::None)));
        assert_eq!("z--w-------  ", wrap_mode(true, Some(0), 0o200, FileKind::File(ExecKind::None)));
        assert_eq!("z---x------  ", wrap_mode(true, Some(0), 0o100, FileKind::File(ExecKind::None)));
        assert_eq!("z----r-----  ", wrap_mode(true, Some(0), 0o040, FileKind::File(ExecKind::None)));
        assert_eq!("z-----w----  ", wrap_mode(true, Some(0), 0o020, FileKind::File(ExecKind::None)));
        assert_eq!("z------x---  ", wrap_mode(true, Some(0), 0o010, FileKind::File(ExecKind::None)));
        assert_eq!("z-------r--  ", wrap_mode(true, Some(0), 0o004, FileKind::File(ExecKind::None)));
        assert_eq!("z--------w-  ", wrap_mode(true, Some(0), 0o002, FileKind::File(ExecKind::None)));
        assert_eq!("z---------x  ", wrap_mode(true, Some(0), 0o001, FileKind::File(ExecKind::None)));
        assert_eq!("z-rwxrwxrwx  ", wrap_mode(true, Some(0), 0o777, FileKind::File(ExecKind::None)));
    }

    #[test]
    fn test_measures_size_for_integer() {
        let config = Config::default();
        assert_eq!(3, measure_size(&config, 0));
        assert_eq!(3, measure_size(&config, 999));
        assert_eq!(7, measure_size(&config, 1_000));
        assert_eq!(7, measure_size(&config, 999_999));
        assert_eq!(11, measure_size(&config, 1_000_000));
        assert_eq!(11, measure_size(&config, 999_999_999));
    }

    #[test]
    fn test_measures_size_for_si_units() {
        let config = Config::default()
            .with_show_pretty(true);
        assert_eq!(6, measure_size(&config, 0));
        assert_eq!(6, measure_size(&config, 999));
        assert_eq!(6, measure_size(&config, 1_000));
        assert_eq!(6, measure_size(&config, 999_999));
        assert_eq!(6, measure_size(&config, 1_000_000));
        assert_eq!(6, measure_size(&config, 999_999_999));
    }

    #[test]
    fn test_prints_unpadded_size_as_integer() {
        let config = Config::default();
        assert_eq!("0  ", wrap_size(&config, 0, 0));
        assert_eq!("9  ", wrap_size(&config, 9, 0));
        assert_eq!("10  ", wrap_size(&config, 10, 0));
        assert_eq!("99  ", wrap_size(&config, 99, 0));
        assert_eq!("100  ", wrap_size(&config, 100, 0));
        assert_eq!("999  ", wrap_size(&config, 999, 0));
        assert_eq!("1,000  ", wrap_size(&config, 1_000, 0));
        assert_eq!("9,999  ", wrap_size(&config, 9_999, 0));
        assert_eq!("10,000  ", wrap_size(&config, 10_000, 0));
        assert_eq!("99,999  ", wrap_size(&config, 99_999, 0));
        assert_eq!("100,000  ", wrap_size(&config, 100_000, 0));
        assert_eq!("999,999  ", wrap_size(&config, 999_999, 0));
        assert_eq!("1,000,000  ", wrap_size(&config, 1_000_000, 0));
        assert_eq!("9,999,999  ", wrap_size(&config, 9_999_999, 0));
        assert_eq!("10,000,000  ", wrap_size(&config, 10_000_000, 0));
        assert_eq!("99,999,999  ", wrap_size(&config, 99_999_999, 0));
        assert_eq!("100,000,000  ", wrap_size(&config, 100_000_000, 0));
        assert_eq!("999,999,999  ", wrap_size(&config, 999_999_999, 0));
        assert_eq!("1,000,000,000  ", wrap_size(&config, 1_000_000_000, 0));
        assert_eq!("9,999,999,999  ", wrap_size(&config, 9_999_999_999, 0));
        assert_eq!("10,000,000,000  ", wrap_size(&config, 10_000_000_000, 0));
        assert_eq!("99,999,999,999  ", wrap_size(&config, 99_999_999_999, 0));
        assert_eq!("100,000,000,000  ", wrap_size(&config, 100_000_000_000, 0));
        assert_eq!("999,999,999,999  ", wrap_size(&config, 999_999_999_999, 0));
        assert_eq!("1,000,000,000,000  ", wrap_size(&config, 1_000_000_000_000, 0));
        assert_eq!("9,999,999,999,999  ", wrap_size(&config, 9_999_999_999_999, 0));
        assert_eq!("10,000,000,000,000  ", wrap_size(&config, 10_000_000_000_000, 0));
        assert_eq!("99,999,999,999,999  ", wrap_size(&config, 99_999_999_999_999, 0));
        assert_eq!("100,000,000,000,000  ", wrap_size(&config, 100_000_000_000_000, 0));
        assert_eq!("999,999,999,999,999  ", wrap_size(&config, 999_999_999_999_999, 0));
        assert_eq!("1,000,000,000,000,000  ", wrap_size(&config, 1_000_000_000_000_000, 0));
        assert_eq!("9,999,999,999,999,999  ", wrap_size(&config, 9_999_999_999_999_999, 0));
        assert_eq!("10,000,000,000,000,000  ", wrap_size(&config, 10_000_000_000_000_000, 0));
        assert_eq!("99,999,999,999,999,999  ", wrap_size(&config, 99_999_999_999_999_999, 0));
        assert_eq!("100,000,000,000,000,000  ", wrap_size(&config, 100_000_000_000_000_000, 0));
        assert_eq!("999,999,999,999,999,999  ", wrap_size(&config, 999_999_999_999_999_999, 0));
        assert_eq!("1,000,000,000,000,000,000  ", wrap_size(&config, 1_000_000_000_000_000_000, 0));
        assert_eq!("9,999,999,999,999,999,999  ", wrap_size(&config, 9_999_999_999_999_999_999, 0));
        assert_eq!("10,000,000,000,000,000,000  ", wrap_size(&config, 10_000_000_000_000_000_000, 0));
    }

    #[test]
    fn test_prints_padded_size_as_integer() {
        let config = Config::default();
        assert_eq!("                         0  ", wrap_size(&config, 0, 26));
        assert_eq!("                         9  ", wrap_size(&config, 9, 26));
        assert_eq!("                        10  ", wrap_size(&config, 10, 26));
        assert_eq!("                        99  ", wrap_size(&config, 99, 26));
        assert_eq!("                       100  ", wrap_size(&config, 100, 26));
        assert_eq!("                       999  ", wrap_size(&config, 999, 26));
        assert_eq!("                     1,000  ", wrap_size(&config, 1_000, 26));
        assert_eq!("                     9,999  ", wrap_size(&config, 9_999, 26));
        assert_eq!("                    10,000  ", wrap_size(&config, 10_000, 26));
        assert_eq!("                    99,999  ", wrap_size(&config, 99_999, 26));
        assert_eq!("                   100,000  ", wrap_size(&config, 100_000, 26));
        assert_eq!("                   999,999  ", wrap_size(&config, 999_999, 26));
        assert_eq!("                 1,000,000  ", wrap_size(&config, 1_000_000, 26));
        assert_eq!("                 9,999,999  ", wrap_size(&config, 9_999_999, 26));
        assert_eq!("                10,000,000  ", wrap_size(&config, 10_000_000, 26));
        assert_eq!("                99,999,999  ", wrap_size(&config, 99_999_999, 26));
        assert_eq!("               100,000,000  ", wrap_size(&config, 100_000_000, 26));
        assert_eq!("               999,999,999  ", wrap_size(&config, 999_999_999, 26));
        assert_eq!("             1,000,000,000  ", wrap_size(&config, 1_000_000_000, 26));
        assert_eq!("             9,999,999,999  ", wrap_size(&config, 9_999_999_999, 26));
        assert_eq!("            10,000,000,000  ", wrap_size(&config, 10_000_000_000, 26));
        assert_eq!("            99,999,999,999  ", wrap_size(&config, 99_999_999_999, 26));
        assert_eq!("           100,000,000,000  ", wrap_size(&config, 100_000_000_000, 26));
        assert_eq!("           999,999,999,999  ", wrap_size(&config, 999_999_999_999, 26));
        assert_eq!("         1,000,000,000,000  ", wrap_size(&config, 1_000_000_000_000, 26));
        assert_eq!("         9,999,999,999,999  ", wrap_size(&config, 9_999_999_999_999, 26));
        assert_eq!("        10,000,000,000,000  ", wrap_size(&config, 10_000_000_000_000, 26));
        assert_eq!("        99,999,999,999,999  ", wrap_size(&config, 99_999_999_999_999, 26));
        assert_eq!("       100,000,000,000,000  ", wrap_size(&config, 100_000_000_000_000, 26));
        assert_eq!("       999,999,999,999,999  ", wrap_size(&config, 999_999_999_999_999, 26));
        assert_eq!("     1,000,000,000,000,000  ", wrap_size(&config, 1_000_000_000_000_000, 26));
        assert_eq!("     9,999,999,999,999,999  ", wrap_size(&config, 9_999_999_999_999_999, 26));
        assert_eq!("    10,000,000,000,000,000  ", wrap_size(&config, 10_000_000_000_000_000, 26));
        assert_eq!("    99,999,999,999,999,999  ", wrap_size(&config, 99_999_999_999_999_999, 26));
        assert_eq!("   100,000,000,000,000,000  ", wrap_size(&config, 100_000_000_000_000_000, 26));
        assert_eq!("   999,999,999,999,999,999  ", wrap_size(&config, 999_999_999_999_999_999, 26));
        assert_eq!(" 1,000,000,000,000,000,000  ", wrap_size(&config, 1_000_000_000_000_000_000, 26));
        assert_eq!(" 9,999,999,999,999,999,999  ", wrap_size(&config, 9_999_999_999_999_999_999, 26));
        assert_eq!("10,000,000,000,000,000,000  ", wrap_size(&config, 10_000_000_000_000_000_000, 26));
    }

    #[test]
    fn test_prints_unpadded_size_in_si_units() {
        let config = Config::default()
            .with_show_pretty(true);
        assert_eq!("  0 B   ", wrap_size(&config, 0, 0));
        assert_eq!("  9 B   ", wrap_size(&config, 9, 0));
        assert_eq!(" 10 B   ", wrap_size(&config, 10, 0));
        assert_eq!(" 99 B   ", wrap_size(&config, 99, 0));
        assert_eq!("100 B   ", wrap_size(&config, 100, 0));
        assert_eq!("999 B   ", wrap_size(&config, 999, 0));
        assert_eq!("  1 KB  ", wrap_size(&config, 1_000, 0));
        assert_eq!("  9 KB  ", wrap_size(&config, 9_999, 0));
        assert_eq!(" 10 KB  ", wrap_size(&config, 10_000, 0));
        assert_eq!(" 99 KB  ", wrap_size(&config, 99_999, 0));
        assert_eq!("100 KB  ", wrap_size(&config, 100_000, 0));
        assert_eq!("999 KB  ", wrap_size(&config, 999_999, 0));
        assert_eq!("  1 MB  ", wrap_size(&config, 1_000_000, 0));
        assert_eq!("  9 MB  ", wrap_size(&config, 9_999_999, 0));
        assert_eq!(" 10 MB  ", wrap_size(&config, 10_000_000, 0));
        assert_eq!(" 99 MB  ", wrap_size(&config, 99_999_999, 0));
        assert_eq!("100 MB  ", wrap_size(&config, 100_000_000, 0));
        assert_eq!("999 MB  ", wrap_size(&config, 999_999_999, 0));
        assert_eq!("  1 GB  ", wrap_size(&config, 1_000_000_000, 0));
        assert_eq!("  9 GB  ", wrap_size(&config, 9_999_999_999, 0));
        assert_eq!(" 10 GB  ", wrap_size(&config, 10_000_000_000, 0));
        assert_eq!(" 99 GB  ", wrap_size(&config, 99_999_999_999, 0));
        assert_eq!("100 GB  ", wrap_size(&config, 100_000_000_000, 0));
        assert_eq!("999 GB  ", wrap_size(&config, 999_999_999_999, 0));
        assert_eq!("  1 TB  ", wrap_size(&config, 1_000_000_000_000, 0));
        assert_eq!("  9 TB  ", wrap_size(&config, 9_999_999_999_999, 0));
        assert_eq!(" 10 TB  ", wrap_size(&config, 10_000_000_000_000, 0));
        assert_eq!(" 99 TB  ", wrap_size(&config, 99_999_999_999_999, 0));
        assert_eq!("100 TB  ", wrap_size(&config, 100_000_000_000_000, 0));
        assert_eq!("999 TB  ", wrap_size(&config, 999_999_999_999_999, 0));
        assert_eq!("  1 PB  ", wrap_size(&config, 1_000_000_000_000_000, 0));
        assert_eq!("  9 PB  ", wrap_size(&config, 9_999_999_999_999_999, 0));
        assert_eq!(" 10 PB  ", wrap_size(&config, 10_000_000_000_000_000, 0));
        assert_eq!(" 99 PB  ", wrap_size(&config, 99_999_999_999_999_999, 0));
        assert_eq!("100 PB  ", wrap_size(&config, 100_000_000_000_000_000, 0));
        assert_eq!("999 PB  ", wrap_size(&config, 999_999_999_999_999_999, 0));
        assert_eq!("  1 EB  ", wrap_size(&config, 1_000_000_000_000_000_000, 0));
        assert_eq!("  9 EB  ", wrap_size(&config, 9_999_999_999_999_999_999, 0));
        assert_eq!(" 10 EB  ", wrap_size(&config, 10_000_000_000_000_000_000, 0));
    }

    #[test]
    fn test_prints_time_as_local_timestamp() {
        let config = Config::default()
            .with_curr_time(2024, 10, 10, 10, 10, 30)
            .with_show_utc(false);
        assert_eq!("31-Jan-2024 00:00:00  ", wrap_time(&config, 2024, 1, 31, 0, 0, 0));
        assert_eq!("29-Feb-2024 02:05:15  ", wrap_time(&config, 2024, 2, 29, 2, 5, 15));
        assert_eq!("31-Mar-2024 04:10:30  ", wrap_time(&config, 2024, 3, 31, 4, 10, 30));
        assert_eq!("30-Apr-2024 06:15:45  ", wrap_time(&config, 2024, 4, 30, 6, 15, 45));
        assert_eq!("31-May-2024 08:20:00  ", wrap_time(&config, 2024, 5, 31, 8, 20, 0));
        assert_eq!("30-Jun-2024 10:25:15  ", wrap_time(&config, 2024, 6, 30, 10, 25, 15));
        assert_eq!("31-Jul-2024 12:30:30  ", wrap_time(&config, 2024, 7, 31, 12, 30, 30));
        assert_eq!("31-Aug-2024 14:35:45  ", wrap_time(&config, 2024, 8, 31, 14, 35, 45));
        assert_eq!("30-Sep-2024 16:40:00  ", wrap_time(&config, 2024, 9, 30, 16, 40, 0));
        assert_eq!("31-Oct-2024 18:45:15  ", wrap_time(&config, 2024, 10, 31, 18, 45, 15));
        assert_eq!("30-Nov-2024 20:50:30  ", wrap_time(&config, 2024, 11, 30, 20, 50, 30));
        assert_eq!("31-Dec-2024 22:55:45  ", wrap_time(&config, 2024, 12, 31, 22, 55, 45));
        assert_eq!("--------------------  ", wrap_time(&config, 1970, 1, 1, 0, 0, 0));
    }

    #[test]
    fn test_prints_time_as_utc_timestamp() {
        let config = Config::default()
            .with_curr_time(2024, 10, 10, 10, 10, 30)
            .with_show_utc(true);
        assert_eq!("31-Jan-2024 00:00:00Z  ", wrap_time(&config, 2024, 1, 31, 0, 0, 0));
        assert_eq!("29-Feb-2024 02:05:15Z  ", wrap_time(&config, 2024, 2, 29, 2, 5, 15));
        assert_eq!("31-Mar-2024 04:10:30Z  ", wrap_time(&config, 2024, 3, 31, 4, 10, 30));
        assert_eq!("30-Apr-2024 06:15:45Z  ", wrap_time(&config, 2024, 4, 30, 6, 15, 45));
        assert_eq!("31-May-2024 08:20:00Z  ", wrap_time(&config, 2024, 5, 31, 8, 20, 0));
        assert_eq!("30-Jun-2024 10:25:15Z  ", wrap_time(&config, 2024, 6, 30, 10, 25, 15));
        assert_eq!("31-Jul-2024 12:30:30Z  ", wrap_time(&config, 2024, 7, 31, 12, 30, 30));
        assert_eq!("31-Aug-2024 14:35:45Z  ", wrap_time(&config, 2024, 8, 31, 14, 35, 45));
        assert_eq!("30-Sep-2024 16:40:00Z  ", wrap_time(&config, 2024, 9, 30, 16, 40, 0));
        assert_eq!("31-Oct-2024 18:45:15Z  ", wrap_time(&config, 2024, 10, 31, 18, 45, 15));
        assert_eq!("30-Nov-2024 20:50:30Z  ", wrap_time(&config, 2024, 11, 30, 20, 50, 30));
        assert_eq!("31-Dec-2024 22:55:45Z  ", wrap_time(&config, 2024, 12, 31, 22, 55, 45));
        assert_eq!("---------------------  ", wrap_time(&config, 1970, 1, 1, 0, 0, 0));
    }

    #[test]
    fn test_prints_time_as_duration() {
        let config = Config::default()
            .with_curr_time(2024, 10, 10, 10, 10, 30)
            .with_show_pretty(true);
        assert_eq!(" future   ", wrap_time(&config, 2024, 10, 10, 10, 10, 31));
        assert_eq!(" 0 sec    ", wrap_time(&config, 2024, 10, 10, 10, 10, 30));
        assert_eq!(" 1 sec    ", wrap_time(&config, 2024, 10, 10, 10, 10, 29));
        assert_eq!("59 sec    ", wrap_time(&config, 2024, 10, 10, 10, 9, 31));
        assert_eq!(" 1 min    ", wrap_time(&config, 2024, 10, 10, 10, 9, 30));
        assert_eq!(" 1 min    ", wrap_time(&config, 2024, 10, 10, 10, 9, 29));
        assert_eq!(" 1 min    ", wrap_time(&config, 2024, 10, 10, 10, 8, 31));
        assert_eq!(" 2 min    ", wrap_time(&config, 2024, 10, 10, 10, 8, 30));
        assert_eq!(" 2 min    ", wrap_time(&config, 2024, 10, 10, 10, 8, 29));
        assert_eq!("58 min    ", wrap_time(&config, 2024, 10, 10, 9, 11, 31));
        assert_eq!("59 min    ", wrap_time(&config, 2024, 10, 10, 9, 11, 30));
        assert_eq!("59 min    ", wrap_time(&config, 2024, 10, 10, 9, 11, 29));
        assert_eq!("59 min    ", wrap_time(&config, 2024, 10, 10, 9, 10, 31));
        assert_eq!(" 1 hour   ", wrap_time(&config, 2024, 10, 10, 9, 10, 30));
        assert_eq!(" 1 hour   ", wrap_time(&config, 2024, 10, 10, 9, 10, 29));
        assert_eq!(" 1 hour   ", wrap_time(&config, 2024, 10, 10, 8, 10, 31));
        assert_eq!(" 2 hour   ", wrap_time(&config, 2024, 10, 10, 8, 10, 30));
        assert_eq!(" 2 hour   ", wrap_time(&config, 2024, 10, 10, 8, 10, 29));
        assert_eq!("22 hour   ", wrap_time(&config, 2024, 10, 9, 11, 10, 31));
        assert_eq!("23 hour   ", wrap_time(&config, 2024, 10, 9, 11, 10, 30));
        assert_eq!("23 hour   ", wrap_time(&config, 2024, 10, 9, 11, 10, 29));
        assert_eq!("23 hour   ", wrap_time(&config, 2024, 10, 9, 10, 10, 31));
        assert_eq!(" 1 day    ", wrap_time(&config, 2024, 10, 9, 10, 10, 30));
        assert_eq!(" 1 day    ", wrap_time(&config, 2024, 10, 9, 10, 10, 29));
        assert_eq!(" 1 day    ", wrap_time(&config, 2024, 10, 8, 10, 10, 31));
        assert_eq!(" 2 day    ", wrap_time(&config, 2024, 10, 8, 10, 10, 30));
        assert_eq!(" 2 day    ", wrap_time(&config, 2024, 10, 8, 10, 10, 29));
        assert_eq!("28 day    ", wrap_time(&config, 2024, 9, 11, 10, 10, 31));
        assert_eq!("29 day    ", wrap_time(&config, 2024, 9, 11, 10, 10, 30));
        assert_eq!("29 day    ", wrap_time(&config, 2024, 9, 11, 10, 10, 29));
        assert_eq!("29 day    ", wrap_time(&config, 2024, 9, 10, 10, 10, 31));
        assert_eq!(" 1 month  ", wrap_time(&config, 2024, 9, 10, 10, 10, 30));
        assert_eq!(" 1 month  ", wrap_time(&config, 2024, 9, 10, 10, 10, 29));
        assert_eq!(" 1 month  ", wrap_time(&config, 2024, 8, 10, 10, 10, 31));
        assert_eq!(" 2 month  ", wrap_time(&config, 2024, 8, 10, 10, 10, 30));
        assert_eq!(" 2 month  ", wrap_time(&config, 2024, 8, 10, 10, 10, 29));
        assert_eq!("10 month  ", wrap_time(&config, 2023, 11, 10, 10, 10, 31));
        assert_eq!("11 month  ", wrap_time(&config, 2023, 11, 10, 10, 10, 30));
        assert_eq!("11 month  ", wrap_time(&config, 2023, 11, 10, 10, 10, 29));
        assert_eq!("11 month  ", wrap_time(&config, 2023, 10, 10, 10, 10, 31));
        assert_eq!(" 1 year   ", wrap_time(&config, 2023, 10, 10, 10, 10, 30));
        assert_eq!(" 1 year   ", wrap_time(&config, 2023, 10, 10, 10, 10, 29));
        assert_eq!(" 1 year   ", wrap_time(&config, 2022, 10, 10, 10, 10, 31));
        assert_eq!(" 2 year   ", wrap_time(&config, 2022, 10, 10, 10, 10, 30));
        assert_eq!(" 2 year   ", wrap_time(&config, 2022, 10, 10, 10, 10, 29));
        assert_eq!("--------  ", wrap_time(&config, 1970, 1, 1, 0, 0, 0));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_unpadded_version() {
        assert_eq!("", wrap_version(None, 0));
        assert_eq!("", wrap_version(Some(""), 0));
        assert_eq!("", wrap_version(Some("9.9.9.9"), 0));
        assert_eq!("", wrap_version(Some("999.999.999.999"), 0));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_padded_version() {
        assert_eq!("            ", wrap_version(None, 10));
        assert_eq!("            ", wrap_version(Some(""), 10));
        assert_eq!("9.9.9.9     ", wrap_version(Some("9.9.9.9"), 10));
        assert_eq!("999.999.999.999  ", wrap_version(Some("999.999.999.999"), 10));
    }

    #[test]
    fn test_prints_unpadded_ext() {
        assert_eq!("", wrap_ext("", 0));
        assert_eq!("", wrap_ext(".txt", 0));
        assert_eq!("", wrap_ext(".extension", 0));
    }

    #[test]
    fn test_prints_padded_ext() {
        assert_eq!("        ", wrap_ext("", 6));
        assert_eq!(".txt    ", wrap_ext(".txt", 6));
        assert_eq!(".extension  ", wrap_ext(".extension", 6));
    }

    #[test]
    fn test_prints_total() {
        assert_eq!("0 files 0 directories", wrap_total(0, 0));
        assert_eq!("1 file 0 directories", wrap_total(1, 0));
        assert_eq!("2 files 0 directories", wrap_total(2, 0));
        assert_eq!("0 files 1 directory", wrap_total(0, 1));
        assert_eq!("0 files 2 directories", wrap_total(0, 2));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_on_windows() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_on_git_bash() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_relative_paths_on_linux() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_on_windows() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]D:\\root\\example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\files\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\files\\colours\\[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]D:\\root\\example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\files\\colours\\[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\files\\colours\\[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\files\\colours\\[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\files\\numbers\\[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\files\\numbers\\one two\\[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_on_git_bash() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]/d/root/example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]/d/root/example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]/d/root/example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]/d/root/example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]/d/root/example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]/d/root/example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_absolute_paths_on_linux() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]/root/example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]/root/example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]/root/example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]/root/example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]/root/example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]/root/example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]/root/example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]/root/example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]/root/example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_with_zip_on_windows() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\[LtRed]files.zip[LtBlue]\\[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset][LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\one two\\[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_with_zip_on_git_bash() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset][LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_relative_paths_with_zip_on_linux() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset][LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset]red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_with_zip_on_windows() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]D:\\root\\example\\[Reset][DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset][LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset]red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\one two\\[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_with_zip_on_git_bash() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]/d/root/example/[Reset][DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset][LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_absolute_paths_with_zip_on_linux() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]/root/example/[Reset][DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset][LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset]red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_paths_with_start_header_on_windows() {
        let expected = "\
Start            01-Jan-2023 00:00:00
-------------------------------------
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_paths_with_start_header_on_git_bash() {
        let expected = "\
Start            01-Jan-2023 00:00:00
-------------------------------------
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_paths_with_start_header_on_linux() {
        let expected = "\
Start            01-Jan-2023 00:00:00
-------------------------------------
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_paths_with_start_header_and_utc_on_windows() {
        let expected = "\
Start            01-Jan-2023 00:00:00Z
--------------------------------------
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example\\[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00Z  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example\\files\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00Z  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00Z  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00Z  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00Z  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00Z  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00Z  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00Z        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00Z  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_show_utc(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_paths_with_start_header_and_utc_on_git_bash() {
        let expected = "\
Start            01-Jan-2023 00:00:00Z
--------------------------------------
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00Z  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00Z  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00Z  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00Z  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00Z  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00Z  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00Z  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00Z        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00Z  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_show_utc(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_paths_with_start_header_and_utc_on_linux() {
        let expected = "\
Start            01-Jan-2023 00:00:00Z
--------------------------------------
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00Z  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00Z  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00Z  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00Z  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00Z  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00Z  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00Z  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00Z        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00Z        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00Z  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_show_utc(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_paths_with_total_footer_on_windows() {
        let expected = "\
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example\\[Reset]
-rwxr-xr-x       10  01-Nov-2023 00:00:00  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--       20  01-Oct-2023 00:00:00  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--       30  01-Sep-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--       40  01-Aug-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--       50  01-Jul-2023 00:00:00  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--       60  01-Jun-2023 00:00:00  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--      999  01-May-2023 00:00:00  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--        0  01-Apr-2023 00:00:00        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--       70  01-Mar-2023 00:00:00  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
-----------------------------------------
Total         1,279                              9 files 5 directories
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_show_total(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_paths_with_total_footer_on_git_bash() {
        let expected = "\
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
-rwxr-xr-x       10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/colours/[Reset]
-rwxr--r--       20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--       30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--       40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--       50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--       60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--      999  01-May-2023 00:00:00  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--        0  01-Apr-2023 00:00:00        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--       70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
-----------------------------------------
Total         1,279                              9 files 5 directories
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_show_total(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_paths_with_total_footer_on_linux() {
        let expected = "\
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/[Reset]
-rwxr-xr-x       10  01-Nov-2023 00:00:00  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/colours/[Reset]
-rwxr--r--       20  01-Oct-2023 00:00:00  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--       30  01-Sep-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--       40  01-Aug-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--       50  01-Jul-2023 00:00:00  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--       60  01-Jun-2023 00:00:00  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--      999  01-May-2023 00:00:00  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--        0  01-Apr-2023 00:00:00        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--       70  01-Mar-2023 00:00:00  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
-----------------------------------------
Total         1,279                              9 files 5 directories
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_show_total(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_pretty_fields_on_windows() {
        let expected = "\
drwxr-xr-x    0 B    1 day          [LtBlue]example\\[Reset]
-rwxr-xr-x   10 B    2 month  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--   20 B    3 month  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30 B    4 month  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--   40 B    5 month  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--   50 B    6 month  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--   60 B    7 month  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999 B    8 month  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0 B    9 month        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--   70 B   10 month  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_pretty_fields_on_git_bash() {
        let expected = "\
drwxr-xr-x    0 B    1 day          [LtBlue]example/[Reset]
-rwxr-xr-x   10 B    2 month  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20 B    3 month  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30 B    4 month  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40 B    5 month  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50 B    6 month  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60 B    7 month  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999 B    8 month  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0 B    9 month        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70 B   10 month  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_pretty_fields_on_linux() {
        let expected = "\
drwxr-xr-x    0 B    1 day          [LtBlue]example/[Reset]
-rwxr-xr-x   10 B    2 month  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20 B    3 month  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30 B    4 month  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40 B    5 month  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50 B    6 month  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60 B    7 month  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999 B    8 month  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0 B    9 month        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70 B   10 month  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_pretty_fields_with_header_and_footer_on_windows() {
        let expected = "\
Start                1 year
----------------------------
drwxr-xr-x    0 B    1 day          [LtBlue]example\\[Reset]
-rwxr-xr-x   10 B    2 month  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--   20 B    3 month  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30 B    4 month  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--   40 B    5 month  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--   50 B    6 month  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--   60 B    7 month  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999 B    8 month  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0 B    9 month        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--   70 B   10 month  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
----------------------------
Total         1 KB                  9 files 5 directories
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_filter_recent(RecentKind::Year(1))
            .with_show_total(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_pretty_fields_with_header_and_footer_on_git_bash() {
        let expected = "\
Start                1 year
----------------------------
drwxr-xr-x    0 B    1 day          [LtBlue]example/[Reset]
-rwxr-xr-x   10 B    2 month  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20 B    3 month  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30 B    4 month  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40 B    5 month  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50 B    6 month  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60 B    7 month  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999 B    8 month  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0 B    9 month        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70 B   10 month  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
----------------------------
Total         1 KB                  9 files 5 directories
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_filter_recent(RecentKind::Year(1))
            .with_show_total(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_pretty_fields_with_header_and_footer_on_linux() {
        let expected = "\
Start                1 year
----------------------------
drwxr-xr-x    0 B    1 day          [LtBlue]example/[Reset]
-rwxr-xr-x   10 B    2 month  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20 B    3 month  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30 B    4 month  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40 B    5 month  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50 B    6 month  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60 B    7 month  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999 B    8 month  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0 B    9 month        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0 B    1 day          [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70 B   10 month  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
----------------------------
Total         1 KB                  9 files 5 directories
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_filter_recent(RecentKind::Year(1))
            .with_show_total(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_file_signature_on_windows() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  424c5545 BLUE  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  47524545 GREE  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  52454400 RED.  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  00000000 ....  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  fffe3334 ..34  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_show_sig(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_file_signature_on_git_bash() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  424c5545 BLUE  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  47524545 GREE  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  52454400 RED.  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  00000000 ....  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  fffe3334 ..34  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_show_sig(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_file_signature_on_linux() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/colours/[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  424c5545 BLUE  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  47524545 GREE  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  52454400 RED.  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  00000000 ....  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  fffe3334 ..34  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_show_sig(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_file_signature_with_header_and_footer_on_windows() {
        let expected = "\
Start                01-Jan-2023 00:00:00
-----------------------------------------
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\[Reset]
-rwxr-xr-x       10  01-Nov-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\colours\\[Reset]
-rwxr--r--       20  01-Oct-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--       30  01-Sep-2023 00:00:00  424c5545 BLUE  .txt  [LtBlue]example\\files\\colours\\[Reset]blue.txt
-rw-r--r--       40  01-Aug-2023 00:00:00  47524545 GREE  .txt  [LtBlue]example\\files\\colours\\[Reset]green.txt
-rw-r--r--       50  01-Jul-2023 00:00:00  52454400 RED.  .txt  [LtBlue]example\\files\\colours\\[Reset]red.txt
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\numbers\\[Reset]
lrwxr--r--       60  01-Jun-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--      999  01-May-2023 00:00:00  00000000 ....  .gz   [LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--        0  01-Apr-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example\\files\\numbers\\one two\\[Reset]
-rw-r--r--       70  01-Mar-2023 00:00:00  fffe3334 ..34  .txt  [LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
-----------------------------------------
Total         1,279                                             9 files 5 directories
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_show_total(true)
            .with_show_sig(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_file_signature_with_header_and_footer_on_git_bash() {
        let expected = "\
Start                01-Jan-2023 00:00:00
-----------------------------------------
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/[Reset]
-rwxr-xr-x       10  01-Nov-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/colours/[Reset]
-rwxr--r--       20  01-Oct-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--       30  01-Sep-2023 00:00:00  424c5545 BLUE  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--       40  01-Aug-2023 00:00:00  47524545 GREE  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--       50  01-Jul-2023 00:00:00  52454400 RED.  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--       60  01-Jun-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--      999  01-May-2023 00:00:00  00000000 ....  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--        0  01-Apr-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--       70  01-Mar-2023 00:00:00  fffe3334 ..34  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
-----------------------------------------
Total         1,279                                             9 files 5 directories
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_show_total(true)
            .with_show_sig(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_file_signature_with_header_and_footer_on_linux() {
        let expected = "\
Start                01-Jan-2023 00:00:00
-----------------------------------------
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/[Reset]
-rwxr-xr-x       10  01-Nov-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/colours/[Reset]
-rwxr--r--       20  01-Oct-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--       30  01-Sep-2023 00:00:00  424c5545 BLUE  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--       40  01-Aug-2023 00:00:00  47524545 GREE  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--       50  01-Jul-2023 00:00:00  52454400 RED.  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset]
lrwxr--r--       60  01-Jun-2023 00:00:00  23212f75 #!/u  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--      999  01-May-2023 00:00:00  00000000 ....  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--        0  01-Apr-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x        0  31-Dec-2023 00:00:00  00000000 ....        [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--       70  01-Mar-2023 00:00:00  fffe3334 ..34  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
-----------------------------------------
Total         1,279                                             9 files 5 directories
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_filter_recent(RecentKind::Year(1))
            .with_show_total(true)
            .with_show_sig(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(not(windows))]
    #[cfg(unix)]
    fn test_prints_owner_information_on_linux() {
        let expected = "\
drwxr-xr-x  alice public    0 B    1 day          [LtBlue]example/[Reset]
-rwxr-xr-x  root  root     10 B    2 month  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x  alice public    0 B    1 day          [LtBlue]example/files/[Reset]
drwxr-xr-x  alice public    0 B    1 day          [LtBlue]example/files/colours/[Reset]
-rwxr--r--  alice public   20 B    3 month  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--  alice public   30 B    4 month  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--  alice public   40 B    5 month  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--  alice public   50 B    6 month  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x  bob   public    0 B    1 day          [LtBlue]example/files/numbers/[Reset]
lrwxr--r--  bob   public   60 B    7 month  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  bob   public  999 B    8 month  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--  bob   public    0 B    9 month        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x  -     -         0 B    1 day          [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--  -     -        70 B   10 month  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_show_owner(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(not(windows))]
    #[cfg(unix)]
    fn test_prints_owner_information_with_header_and_footer_on_linux() {
        let expected = "\
Start                              1 year
------------------------------------------
drwxr-xr-x  alice public    0 B    1 day          [LtBlue]example/[Reset]
-rwxr-xr-x  root  root     10 B    2 month  .sh   [LtBlue]example/[Reset][DkGreen]find.sh[Reset]
drwxr-xr-x  alice public    0 B    1 day          [LtBlue]example/files/[Reset]
drwxr-xr-x  alice public    0 B    1 day          [LtBlue]example/files/colours/[Reset]
-rwxr--r--  alice public   20 B    3 month  .sh   [LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
-rw-r--r--  alice public   30 B    4 month  .txt  [LtBlue]example/files/colours/[Reset]blue.txt
-rw-r--r--  alice public   40 B    5 month  .txt  [LtBlue]example/files/colours/[Reset]green.txt
-rw-r--r--  alice public   50 B    6 month  .txt  [LtBlue]example/files/colours/[Reset]red.txt
drwxr-xr-x  bob   public    0 B    1 day          [LtBlue]example/files/numbers/[Reset]
lrwxr--r--  bob   public   60 B    7 month  .sh   [LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  bob   public  999 B    8 month  .gz   [LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--  bob   public    0 B    9 month        [LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x  -     -         0 B    1 day          [LtBlue]example/files/numbers/one two/[Reset]
-rw-r--r--  -     -        70 B   10 month  .txt  [LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
------------------------------------------
Total                       1 KB                  9 files 5 directories
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_curr_time(2024, 1, 1, 0, 0, 0)
            .with_show_pretty(true)
            .with_show_owner(true)
            .with_filter_recent(RecentKind::Year(1))
            .with_show_total(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_version_numbers_on_windows() {
        let expected = "\
-rwxr--r--  999  01-Jan-2024 00:00:00  12.3.4.0   .exe  [LtGreen]binary.exe[Reset]
-rwxr--r--  999  01-Jan-2024 00:00:00  5.67.89.0  .dll  library.dll
-rw-r--r--  999  01-Jan-2024 00:00:00             .txt  readme.txt
";
        let files = create_files_with_version();
        let config = Config::default()
            .with_win_ver(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_version_numbers_on_git_bash() {
        let expected = "\
-rwxr--r--  999  01-Jan-2024 00:00:00  12.3.4.0   .exe  [LtGreen]binary.exe[Reset]
-rwxr--r--  999  01-Jan-2024 00:00:00  5.67.89.0  .dll  library.dll
-rw-r--r--  999  01-Jan-2024 00:00:00             .txt  readme.txt
";
        let files = create_files_with_version();
        let config = Config::default()
            .with_win_ver(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_no_attributes_on_windows() {
        let expected = "\
[LtBlue]example\\[Reset]
[LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
[LtBlue]example\\files\\[Reset]
[LtBlue]example\\files\\colours\\[Reset]
[LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]example\\files\\colours\\[Reset]blue.txt
[LtBlue]example\\files\\colours\\[Reset]green.txt
[LtBlue]example\\files\\colours\\[Reset]red.txt
[LtBlue]example\\files\\numbers\\[Reset]
[LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
[LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
[LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
[LtBlue]example\\files\\numbers\\one two\\[Reset]
[LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_no_attributes_on_git_bash() {
        let expected = "\
[LtBlue]example/[Reset]
[LtBlue]example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]example/files/[Reset]
[LtBlue]example/files/colours/[Reset]
[LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]example/files/colours/[Reset]blue.txt
[LtBlue]example/files/colours/[Reset]green.txt
[LtBlue]example/files/colours/[Reset]red.txt
[LtBlue]example/files/numbers/[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
[LtBlue]example/files/numbers/one two/[Reset]
[LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_relative_paths_no_attributes_on_linux() {
        let expected = "\
[LtBlue]example/[Reset]
[LtBlue]example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]example/files/[Reset]
[LtBlue]example/files/colours/[Reset]
[LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]example/files/colours/[Reset]blue.txt
[LtBlue]example/files/colours/[Reset]green.txt
[LtBlue]example/files/colours/[Reset]red.txt
[LtBlue]example/files/numbers/[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
[LtBlue]example/files/numbers/one two/[Reset]
[LtBlue]example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_no_attributes_on_windows() {
        let expected = "\
[LtBlue]D:\\root\\example\\[Reset]
[LtBlue]D:\\root\\example\\[Reset][DkGreen]find.sh[Reset]
[LtBlue]D:\\root\\example\\files\\[Reset]
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]
[LtBlue]D:\\root\\example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]blue.txt
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]green.txt
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]red.txt
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\one two\\[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_no_attributes_on_git_bash() {
        let expected = "\
[LtBlue]/d/root/example/[Reset]
[LtBlue]/d/root/example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]/d/root/example/files/[Reset]
[LtBlue]/d/root/example/files/colours/[Reset]
[LtBlue]/d/root/example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]/d/root/example/files/colours/[Reset]blue.txt
[LtBlue]/d/root/example/files/colours/[Reset]green.txt
[LtBlue]/d/root/example/files/colours/[Reset]red.txt
[LtBlue]/d/root/example/files/numbers/[Reset]
[LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
[LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
[LtBlue]/d/root/example/files/numbers/one two/[Reset]
[LtBlue]/d/root/example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_absolute_paths_no_attributes_on_linux() {
        let expected = "\
[LtBlue]/root/example/[Reset]
[LtBlue]/root/example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]/root/example/files/[Reset]
[LtBlue]/root/example/files/colours/[Reset]
[LtBlue]/root/example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]/root/example/files/colours/[Reset]blue.txt
[LtBlue]/root/example/files/colours/[Reset]green.txt
[LtBlue]/root/example/files/colours/[Reset]red.txt
[LtBlue]/root/example/files/numbers/[Reset]
[LtBlue]/root/example/files/numbers/[Reset][LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[LtBlue]/root/example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
[LtBlue]/root/example/files/numbers/[Reset][LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
[LtBlue]/root/example/files/numbers/one two/[Reset]
[LtBlue]/root/example/files/numbers/one two/[Reset]\"three\" 'four'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_with_escaping_on_windows() {
        let expected = "\
[LtBlue]example\\[Reset]
[LtBlue]example\\[Reset][DkGreen]find.sh[Reset]
[LtBlue]example\\files\\[Reset]
[LtBlue]example\\files\\colours\\[Reset]
[LtBlue]example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]example\\files\\colours\\[Reset]blue.txt
[LtBlue]example\\files\\colours\\[Reset]green.txt
[LtBlue]example\\files\\colours\\[Reset]red.txt
[LtBlue]example\\files\\numbers\\[Reset]
[LtBlue]example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset]
[LtBlue]example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset]
[LtBlue]example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset]
[LtBlue]example\\files\\numbers\\one two\\[Reset]
[LtBlue]example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_escape_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_with_escaping_on_git_bash() {
        let expected = "\
[LtBlue]example/[Reset]
[LtBlue]example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]example/files/[Reset]
[LtBlue]example/files/colours/[Reset]
[LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]example/files/colours/[Reset]blue.txt
[LtBlue]example/files/colours/[Reset]green.txt
[LtBlue]example/files/colours/[Reset]red.txt
[LtBlue]example/files/numbers/[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset]
[LtBlue]example/files/numbers/one\\ two/[Reset]
[LtBlue]example/files/numbers/one\\ two/[Reset]\\\"three\\\"\\ \\'four\\'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_escape_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_relative_paths_with_escaping_on_linux() {
        let expected = "\
[LtBlue]example/[Reset]
[LtBlue]example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]example/files/[Reset]
[LtBlue]example/files/colours/[Reset]
[LtBlue]example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]example/files/colours/[Reset]blue.txt
[LtBlue]example/files/colours/[Reset]green.txt
[LtBlue]example/files/colours/[Reset]red.txt
[LtBlue]example/files/numbers/[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]count.sh[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset]
[LtBlue]example/files/numbers/[Reset][LtCyan]ordinals[Reset]
[LtBlue]example/files/numbers/one\\ two/[Reset]
[LtBlue]example/files/numbers/one\\ two/[Reset]\\\"three\\\"\\ \\'four\\'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_escape_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_with_escaping_on_windows() {
        let expected = "\
[LtBlue]D:\\root\\example\\[Reset]
[LtBlue]D:\\root\\example\\[Reset][DkGreen]find.sh[Reset]
[LtBlue]D:\\root\\example\\files\\[Reset]
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]
[LtBlue]D:\\root\\example\\files\\colours\\[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]blue.txt
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]green.txt
[LtBlue]D:\\root\\example\\files\\colours\\[Reset]red.txt
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]count.sh[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]googolplex.gz[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\[Reset][LtCyan]ordinals[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\one two\\[Reset]
[LtBlue]D:\\root\\example\\files\\numbers\\one two\\[Reset]\"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_escape_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_with_escaping_on_git_bash() {
        let expected = "\
[LtBlue]/d/root/example/[Reset]
[LtBlue]/d/root/example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]/d/root/example/files/[Reset]
[LtBlue]/d/root/example/files/colours/[Reset]
[LtBlue]/d/root/example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]/d/root/example/files/colours/[Reset]blue.txt
[LtBlue]/d/root/example/files/colours/[Reset]green.txt
[LtBlue]/d/root/example/files/colours/[Reset]red.txt
[LtBlue]/d/root/example/files/numbers/[Reset]
[LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]count.sh[Reset]
[LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset]
[LtBlue]/d/root/example/files/numbers/[Reset][LtCyan]ordinals[Reset]
[LtBlue]/d/root/example/files/numbers/one\\ two/[Reset]
[LtBlue]/d/root/example/files/numbers/one\\ two/[Reset]\\\"three\\\"\\ \\'four\\'.txt
";
        let files = create_files("D:", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_escape_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_absolute_paths_with_escaping_on_linux() {
        let expected = "\
[LtBlue]/root/example/[Reset]
[LtBlue]/root/example/[Reset][DkGreen]find.sh[Reset]
[LtBlue]/root/example/files/[Reset]
[LtBlue]/root/example/files/colours/[Reset]
[LtBlue]/root/example/files/colours/[Reset][LtGreen]alpha.sh[Reset]
[LtBlue]/root/example/files/colours/[Reset]blue.txt
[LtBlue]/root/example/files/colours/[Reset]green.txt
[LtBlue]/root/example/files/colours/[Reset]red.txt
[LtBlue]/root/example/files/numbers/[Reset]
[LtBlue]/root/example/files/numbers/[Reset][LtCyan]count.sh[Reset]
[LtBlue]/root/example/files/numbers/[Reset][LtCyan]googolplex.gz[Reset]
[LtBlue]/root/example/files/numbers/[Reset][LtCyan]ordinals[Reset]
[LtBlue]/root/example/files/numbers/one\\ two/[Reset]
[LtBlue]/root/example/files/numbers/one\\ two/[Reset]\\\"three\\\"\\ \\'four\\'.txt
";
        let files = create_files("", "/root", "");
        let config = Config::default()
            .with_only_path(true)
            .with_escape_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_sorted_by_name_on_windows() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]example\\files\\colours\\[Reset])
blue.txt ([LtBlue]example\\files\\colours\\[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]example\\files\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]example\\[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]example\\files\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]example\\files\\colours\\[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]example\\files\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
red.txt ([LtBlue]example\\files\\colours\\[Reset])
\"three\" 'four'.txt ([LtBlue]example\\files\\numbers\\one two\\[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let config = Config::default()
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_sorted_by_name_on_git_bash() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]example/files/colours/[Reset])
blue.txt ([LtBlue]example/files/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]example/files/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]example/files/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]example/files/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]example/files/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]example/files/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]example/files/numbers/one two/[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let config = Config::default()
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_relative_paths_sorted_by_name_on_linux() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]example/files/colours/[Reset])
blue.txt ([LtBlue]example/files/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]example/files/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]example/files/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]example/files/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]example/files/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]example/files/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]example/files/numbers/one two/[Reset])
";
        let files = create_files("", "/root", "");
        let files = modify_files_by_name(files);
        let config = Config::default()
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_sorted_by_name_on_windows() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]D:\\root\\example\\files\\colours\\[Reset])
blue.txt ([LtBlue]D:\\root\\example\\files\\colours\\[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]D:\\root\\example\\files\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]D:\\root\\example\\[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]D:\\root\\example\\files\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]D:\\root\\example\\files\\colours\\[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]D:\\root\\example\\files\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
red.txt ([LtBlue]D:\\root\\example\\files\\colours\\[Reset])
\"three\" 'four'.txt ([LtBlue]D:\\root\\example\\files\\numbers\\one two\\[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let config = Config::default()
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_sorted_by_name_on_git_bash() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]/d/root/example/files/colours/[Reset])
blue.txt ([LtBlue]/d/root/example/files/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]/d/root/example/files/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]/d/root/example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]/d/root/example/files/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]/d/root/example/files/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]/d/root/example/files/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]/d/root/example/files/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]/d/root/example/files/numbers/one two/[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let config = Config::default()
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_absolute_paths_sorted_by_name_on_linux() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]/root/example/files/colours/[Reset])
blue.txt ([LtBlue]/root/example/files/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]/root/example/files/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]/root/example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]/root/example/files/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]/root/example/files/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]/root/example/files/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]/root/example/files/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]/root/example/files/numbers/one two/[Reset])
";
        let files = create_files("", "/root", "");
        let files = modify_files_by_name(files);
        let config = Config::default()
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_with_zip_sorted_by_name_on_windows() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
blue.txt ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]example\\[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
red.txt ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
\"three\" 'four'.txt ([LtBlue]example\\[LtRed]files.zip[LtBlue]\\numbers\\one two\\[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_relative_paths_with_zip_sorted_by_name_on_git_bash() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
blue.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_relative_paths_with_zip_sorted_by_name_on_linux() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
blue.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset])
";
        let files = create_files("", "/root", "");
        let files = modify_files_by_name(files);
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(false);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_with_zip_sorted_by_name_on_windows() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
blue.txt ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]D:\\root\\example\\[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\[Reset]) -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
red.txt ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\colours\\[Reset])
\"three\" 'four'.txt ([LtBlue]D:\\root\\example\\[LtRed]files.zip[LtBlue]\\numbers\\one two\\[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_absolute_paths_with_zip_sorted_by_name_on_git_bash() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
blue.txt ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]/d/root/example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]/d/root/example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset])
";
        let files = create_files("D:", "/root", "");
        let files = modify_files_by_name(files);
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_absolute_paths_with_zip_sorted_by_name_on_linux() {
        let expected = "\
[LtGreen]alpha.sh[Reset] ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
blue.txt ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]count.sh[Reset] ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
[DkGreen]find.sh[Reset] ([LtBlue]/root/example/[Reset])
[LtCyan]googolplex.gz[Reset] ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
green.txt ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
[LtCyan]ordinals[Reset] ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/[Reset]) -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
red.txt ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/colours/[Reset])
\"three\" 'four'.txt ([LtBlue]/root/example/[LtRed]files.zip[LtBlue]/numbers/one two/[Reset])
";
        let files = create_files("", "/root", "");
        let files = modify_files_by_name(files);
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_order_name(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_with_attributes_on_windows() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh    [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00         [LtBlue]\\-[Reset] [LtBlue]files[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]+-[Reset] [LtBlue]colours[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh        [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh            [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz            [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00                 [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00                 [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt               [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let config = Config::default()
            .with_show_indent(true)
            .with_only_path(false)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_with_attributes_on_git_bash() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh    [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00         [LtBlue]\\-[Reset] [LtBlue]files[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]+-[Reset] [LtBlue]colours[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh        [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh            [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz            [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00                 [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00                 [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt               [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let config = Config::default()
            .with_show_indent(true)
            .with_only_path(false)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_indented_paths_with_attributes_on_linux() {
        let expected = "\
drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example[Reset]
-rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh    [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00         [LtBlue]\\-[Reset] [LtBlue]files[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]+-[Reset] [LtBlue]colours[Reset]
-rwxr--r--   20  01-Oct-2023 00:00:00  .sh        [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
-rw-r--r--   30  01-Sep-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
-rw-r--r--   40  01-Aug-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
-rw-r--r--   50  01-Jul-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
drwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
lrwxr--r--   60  01-Jun-2023 00:00:00  .sh            [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
lrw-r--r--  999  01-May-2023 00:00:00  .gz            [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
lrw-r--r--    0  01-Apr-2023 00:00:00                 [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
drwxr-xr-x    0  31-Dec-2023 00:00:00                 [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
-rw-r--r--   70  01-Mar-2023 00:00:00  .txt               [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("", "/root", "../..");
        let config = Config::default()
            .with_show_indent(true)
            .with_only_path(false)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_no_attributes_on_windows() {
        let expected = "\
[LtBlue]example[Reset]
 [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
 [LtBlue]\\-[Reset] [LtBlue]files[Reset]
     [LtBlue]+-[Reset] [LtBlue]colours[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
     [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
     [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
         [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
         [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
         [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
         [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
             [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let config = Config::default()
            .with_show_indent(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_no_attributes_on_git_bash() {
        let expected = "\
[LtBlue]example[Reset]
 [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
 [LtBlue]\\-[Reset] [LtBlue]files[Reset]
     [LtBlue]+-[Reset] [LtBlue]colours[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
     [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
     [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
         [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
         [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
         [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
         [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
             [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let config = Config::default()
            .with_show_indent(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_indented_paths_no_attributes_on_linux() {
        let expected = "\
[LtBlue]example[Reset]
 [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
 [LtBlue]\\-[Reset] [LtBlue]files[Reset]
     [LtBlue]+-[Reset] [LtBlue]colours[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
     [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
     [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
         [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
         [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
         [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
         [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
             [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("", "/root", "../..");
        let config = Config::default()
            .with_show_indent(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_with_zip_with_attributes_on_windows() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh    [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00         [LtBlue]\\-[Reset] [LtRed]files.zip[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]+-[Reset] [LtBlue]colours[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh        [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh            [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz            [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00                 [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00                 [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt               [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_show_indent(true)
            .with_only_path(false)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_with_zip_with_attributes_on_git_bash() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh    [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00         [LtBlue]\\-[Reset] [LtRed]files.zip[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]+-[Reset] [LtBlue]colours[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh        [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh            [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz            [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00                 [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00                 [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt               [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_show_indent(true)
            .with_only_path(false)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_indented_paths_with_zip_with_attributes_on_linux() {
        let expected = "\
-drwxr-xr-x    0  31-Dec-2023 00:00:00        [LtBlue]example[Reset]
--rwxr-xr-x   10  01-Nov-2023 00:00:00  .sh    [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00         [LtBlue]\\-[Reset] [LtRed]files.zip[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]+-[Reset] [LtBlue]colours[Reset]
z-rwxr--r--   20  01-Oct-2023 00:00:00  .sh        [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
z-rw-r--r--   30  01-Sep-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
z-rw-r--r--   40  01-Aug-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
z-rw-r--r--   50  01-Jul-2023 00:00:00  .txt       [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
zdrwxr-xr-x    0  31-Dec-2023 00:00:00             [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
zlrwxr--r--   60  01-Jun-2023 00:00:00  .sh            [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
zlrw-r--r--  999  01-May-2023 00:00:00  .gz            [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
zlrw-r--r--    0  01-Apr-2023 00:00:00                 [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
zdrwxr-xr-x    0  31-Dec-2023 00:00:00                 [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
z-rw-r--r--   70  01-Mar-2023 00:00:00  .txt               [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("", "/root", "../..");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_show_indent(true)
            .with_only_path(false)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_with_zip_no_attributes_on_windows() {
        let expected = "\
[LtBlue]example[Reset]
 [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
 [LtBlue]\\-[Reset] [LtRed]files.zip[Reset]
     [LtBlue]+-[Reset] [LtBlue]colours[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
     [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
     [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
         [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtGreen]count.sh[Reset]
         [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtRed]googolplex.gz[Reset]
         [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]D:\\etc\\numbers\\[Reset][LtBlue]ordinals\\[Reset]
         [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
             [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_show_indent(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    #[test]
    #[cfg(windows)]
    fn test_prints_indented_paths_with_zip_no_attributes_on_git_bash() {
        let expected = "\
[LtBlue]example[Reset]
 [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
 [LtBlue]\\-[Reset] [LtRed]files.zip[Reset]
     [LtBlue]+-[Reset] [LtBlue]colours[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
     [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
     [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
         [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtGreen]count.sh[Reset]
         [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
         [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/d/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
         [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
             [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("D:", "/root", "../..");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_show_indent(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, true, &files));
    }

    #[test]
    #[cfg(not(windows))]
    fn test_prints_indented_paths_with_zip_no_attributes_on_linux() {
        let expected = "\
[LtBlue]example[Reset]
 [LtBlue]+-[Reset] [DkGreen]find.sh[Reset]
 [LtBlue]\\-[Reset] [LtRed]files.zip[Reset]
     [LtBlue]+-[Reset] [LtBlue]colours[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] [LtGreen]alpha.sh[Reset]
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] blue.txt
     [LtBlue]|[Reset]   [LtBlue]+-[Reset] green.txt
     [LtBlue]|[Reset]   [LtBlue]\\-[Reset] red.txt
     [LtBlue]\\-[Reset] [LtBlue]numbers[Reset]
         [LtBlue]+-[Reset] [LtCyan]count.sh[Reset] -> [LtBlue]/etc/numbers/[Reset][LtGreen]count.sh[Reset]
         [LtBlue]+-[Reset] [LtCyan]googolplex.gz[Reset] -> [LtBlue]/etc/numbers/[Reset][LtRed]googolplex.gz[Reset]
         [LtBlue]+-[Reset] [LtCyan]ordinals[Reset] -> [LtBlue]/etc/numbers/[Reset][LtBlue]ordinals/[Reset]
         [LtBlue]\\-[Reset] [LtBlue]one two[Reset]
             [LtBlue]\\-[Reset] \"three\" 'four'.txt
";
        let files = create_files("", "/root", "../..");
        let files = modify_files_for_zip(files);
        let config = Config::default()
            .with_zip_expand(true)
            .with_show_indent(true)
            .with_only_path(true)
            .with_abs_path(true);
        assert_eq!(expected, wrap_files(&config, false, &files));
    }

    fn wrap_mode(
        zip_expand: bool,
        zip_depth: Option<usize>,
        file_mode: u32,
        file_type: FileKind,
    ) -> String {
        let config = Config::default().with_zip_expand(zip_expand);
        wrap_function(&config, false, |p| p.print_mode(file_type, file_mode, zip_depth))
    }

    fn wrap_size(config: &Config, file_size: u64, size_width: usize) -> String {
        wrap_function(config, false, |p| p.print_size(file_size, size_width))
    }

    fn wrap_time(
        config: &Config,
        year: i32,
        month: u32,
        day: u32,
        hour: u32,
        minute: u32,
        second: u32,
    ) -> String {
        let time = Utc.with_ymd_and_hms(year, month, day, hour, minute, second).unwrap();
        wrap_function(config, false, |p| p.print_time(&time, &Utc, true))
    }

    #[cfg(windows)]
    fn wrap_version(file_ver: Option<&str>, ver_width: usize) -> String {
        let config = Config::default();
        let file_ver = file_ver.map(str::to_string);
        wrap_function(&config, false, |p| p.print_version(&file_ver, ver_width))
    }

    fn wrap_ext(file_ext: &str, ext_width: usize) -> String {
        let config = Config::default();
        wrap_function(&config, false, |p| p.print_ext(file_ext, ext_width))
    }

    fn wrap_total(num_files: usize, num_dirs: usize) -> String {
        let config = Config::default();
        let mut total = Total::new(None);
        total.num_files = num_files;
        total.num_dirs = num_dirs;
        wrap_function(&config, false, |p| p.print_summary(&total))
    }

    fn wrap_files(config: &Config, git_bash: bool, files: &Vec<File>) -> String {
        let total = create_total(config, files);
        wrap_function(config, git_bash, |p| p.print_files(files, &total, &Utc))
    }

    fn wrap_function<F>(config: &Config, git_bash: bool, func: F) -> String
        where F: FnOnce(&mut Printer<BufferWrapper>) -> MyResult<()>
    {
        let mut buffer = String::new();
        let writer = unsafe { BufferWrapper::new(buffer.as_mut_vec()) };
        let colors = Some(String::from("*.gz=01;31:*.zip=01;31:*.png=01;35"));
        let colors = ColorMap::new(colors);
        let chars = IndentChars {
            branching: '+',
            terminating: '\\',
            horizontal: '-',
            vertical: '|',
        };
        let mut printer = Printer::new(
            config,
            &Utc,
            writer,
            colors,
            chars,
            git_bash,
        );
        func(&mut printer).unwrap();
        buffer
    }

    fn create_files(drive: &str, abs_prefix: &str, rel_prefix: &str) -> Vec<File> {
        let abs_prefix = drive.to_string() + abs_prefix;
        let link_exec = PathBuf::from(drive.to_string() + "/etc/numbers/count.sh").clean();
        let link_file = PathBuf::from(drive.to_string() + "/etc/numbers/googolplex.gz").clean();
        let link_dir = PathBuf::from(drive.to_string() + "/etc/numbers/ordinals").clean();
        vec![
            create_file(&abs_prefix, rel_prefix, "example", "", "")
                .with_type(FileKind::Dir)
                .with_mode(0o755)
                .with_owner_ref("alice", "public")
                .with_size(0)
                .with_date(2023, 12, 31),
            create_file(&abs_prefix, rel_prefix, "example", "find", ".sh")
                .with_type(FileKind::File(ExecKind::Other))
                .with_mode(0o755)
                .with_owner_ref("root", "root")
                .with_size(10)
                .with_date(2023, 11, 01)
                .with_sig_str("#!/u"),
            create_file(&abs_prefix, rel_prefix, "example/files", "", "")
                .with_type(FileKind::Dir)
                .with_mode(0o755)
                .with_owner_ref("alice", "public")
                .with_size(0)
                .with_date(2023, 12, 31),
            create_file(&abs_prefix, rel_prefix, "example/files/colours", "", "")
                .with_type(FileKind::Dir)
                .with_mode(0o755)
                .with_owner_ref("alice", "public")
                .with_size(0)
                .with_date(2023, 12, 31),
            create_file(&abs_prefix, rel_prefix, "example/files/colours", "alpha", ".sh")
                .with_type(FileKind::File(ExecKind::User))
                .with_mode(0o744)
                .with_owner_ref("alice", "public")
                .with_size(20)
                .with_date(2023, 10, 01)
                .with_sig_str("#!/u"),
            create_file(&abs_prefix, rel_prefix, "example/files/colours", "blue", ".txt")
                .with_type(FileKind::File(ExecKind::None))
                .with_mode(0o644)
                .with_owner_ref("alice", "public")
                .with_size(30)
                .with_date(2023, 09, 01)
                .with_sig_str("BLUE"),
            create_file(&abs_prefix, rel_prefix, "example/files/colours", "green", ".txt")
                .with_type(FileKind::File(ExecKind::None))
                .with_mode(0o644)
                .with_owner_ref("alice", "public")
                .with_size(40)
                .with_date(2023, 08, 01)
                .with_sig_str("GREE"),
            create_file(&abs_prefix, rel_prefix, "example/files/colours", "red", ".txt")
                .with_type(FileKind::File(ExecKind::None))
                .with_mode(0o644)
                .with_owner_ref("alice", "public")
                .with_size(50)
                .with_date(2023, 07, 01)
                .with_sig_str("RED"),
            create_file(&abs_prefix, rel_prefix, "example/files/numbers", "", "")
                .with_type(FileKind::Dir)
                .with_mode(0o755)
                .with_owner_ref("bob", "public")
                .with_size(0)
                .with_date(2023, 12, 31),
            create_file(&abs_prefix, rel_prefix, "example/files/numbers", "count", ".sh")
                .with_type(FileKind::Link(true))
                .with_mode(0o744)
                .with_owner_ref("bob", "public")
                .with_size(60)
                .with_date(2023, 06, 01)
                .with_sig_str("#!/u")
                .with_link(link_exec, FileKind::File(ExecKind::User)),
            create_file(&abs_prefix, rel_prefix, "example/files/numbers", "googolplex", ".gz")
                .with_type(FileKind::Link(true))
                .with_mode(0o644)
                .with_owner_ref("bob", "public")
                .with_size(999)
                .with_date(2023, 05, 01)
                .with_link(link_file, FileKind::File(ExecKind::None)),
            create_file(&abs_prefix, rel_prefix, "example/files/numbers", "ordinals", "")
                .with_type(FileKind::Link(true))
                .with_mode(0o644)
                .with_owner_ref("bob", "public")
                .with_size(0)
                .with_date(2023, 04, 01)
                .with_link(link_dir, FileKind::Dir),
            create_file(&abs_prefix, rel_prefix, "example/files/numbers/one two", "", "")
                .with_type(FileKind::Dir)
                .with_mode(0o755)
                .with_size(0)
                .with_date(2023, 12, 31),
            create_file(&abs_prefix, rel_prefix, "example/files/numbers/one two", "\"three\" 'four'", ".txt")
                .with_type(FileKind::File(ExecKind::None))
                .with_mode(0o644)
                .with_size(70)
                .with_date(2023, 03, 01)
                .with_sig(Some([0xff, 0xfe, 0x33, 0x34])),
        ]
    }

    fn modify_files_by_name(files: Vec<File>) -> Vec<File> {
        let mut files = files.into_iter()
            .filter(|file| file.file_type != FileKind::Dir)
            .collect::<Vec<File>>();
        files.sort_by(&compare_files_by_name);
        files
    }

    fn compare_files_by_name(left: &File, right: &File) -> Ordering {
        let left = left.file_name.trim_start_matches("\"");
        let right = right.file_name.trim_start_matches("\"");
        left.cmp(&right)
    }

    fn modify_files_for_zip(files: Vec<File>) -> Vec<File> {
        files.into_iter().map(modify_file_for_zip).collect()
    }

    fn modify_file_for_zip(file: File) -> File {
        let (abs_dir, mut zip_depth) = modify_dir_for_zip(&file.abs_dir);
        let (rel_dir, _) = modify_dir_for_zip(&file.rel_dir);
        if file.file_type != FileKind::Dir {
            zip_depth = zip_depth.map(|depth| depth + 1);
        }
        file.with_dirs(abs_dir, rel_dir).with_zip_depth(zip_depth)
    }

    fn modify_dir_for_zip(old_dir: &Path) -> (PathBuf, Option<usize>) {
        let mut new_dir = PathBuf::new();
        let mut zip_depth = None;
        for component in old_dir.components() {
            if let Component::Normal(dir) = component {
                if dir == "files" {
                    new_dir.push("files.zip");
                    zip_depth = Some(0);
                    continue;
                }
            }
            new_dir.push(component);
            zip_depth = zip_depth.map(|depth| depth + 1);
        }
        (new_dir, zip_depth)
    }

    #[cfg(windows)]
    fn create_files_with_version() -> Vec<File> {
        vec![
            create_file("", "", "", "binary", ".exe")
                .with_type(FileKind::File(ExecKind::User))
                .with_mode(0o744)
                .with_size(999)
                .with_date(2024, 01, 01)
                .with_version(String::from("12.3.4.0")),
            create_file("", "", "", "library", ".dll")
                .with_type(FileKind::File(ExecKind::None))
                .with_mode(0o744)
                .with_size(999)
                .with_date(2024, 01, 01)
                .with_version(String::from("5.67.89.0")),
            create_file("", "", "", "readme", ".txt")
                .with_type(FileKind::File(ExecKind::None))
                .with_mode(0o644)
                .with_size(999)
                .with_date(2024, 01, 01),
        ]
    }

    fn create_file(
        abs_prefix: &str,
        rel_prefix: &str,
        file_dir: &str,
        file_name: &str,
        file_ext: &str,
    ) -> File {
        let abs_dir = PathBuf::from(abs_prefix).join(file_dir).clean();
        let rel_dir = PathBuf::from(rel_prefix).join(file_dir).clean();
        let file_depth = PathBuf::from(file_dir).join(file_name).components().count();
        let file_name = format!("{file_name}{file_ext}");
        let file_ext = String::from(file_ext);
        File::new(abs_dir, rel_dir, file_depth, None, file_name, file_ext, FileKind::Other)
    }

    fn create_total(config: &Config, files: &Vec<File>) -> Total {
        let start_time = Utc.with_ymd_and_hms(2023, 1, 1, 0, 0, 0).unwrap();
        Total::from_files(Some(start_time), config, files)
    }

    struct BufferWrapper<'a> {
        buffer: &'a mut Vec<u8>,
    }

    impl<'a> BufferWrapper<'a> {
        fn new(buffer: &'a mut Vec<u8>) -> Self {
            Self { buffer }
        }
    }

    impl<'a> Write for BufferWrapper<'a> {
        fn write(&mut self, buffer: &[u8]) -> io::Result<usize> {
            self.buffer.write(buffer)
        }

        fn flush(&mut self) -> io::Result<()> {
            Ok(())
        }
    }

    impl<'a> WriteColor for BufferWrapper<'a> {
        fn supports_color(&self) -> bool {
            false
        }

        fn set_color(&mut self, color: &ColorSpec) -> io::Result<()> {
            let bold = if color.bold() { "Lt" } else { "Dk" };
            let fg = match color.fg() {
                Some(Color::Black) => "Black",
                Some(Color::Blue) => "Blue",
                Some(Color::Green) => "Green",
                Some(Color::Red) => "Red",
                Some(Color::Cyan) => "Cyan",
                Some(Color::Magenta) => "Magenta",
                Some(Color::Yellow) => "Yellow",
                Some(Color::White) => "White",
                Some(_) => "Other",
                None => "None",
            };
            write!(&mut self.buffer, "[{bold}{fg}]")?;
            Ok(())
        }

        fn reset(&mut self) -> io::Result<()> {
            write!(&mut self.buffer, "[Reset]")?;
            Ok(())
        }
    }
}