diff --git a/src/fs/id_mapping.rs b/src/fs/id_mapping.rs
index 3bade1f..41d7d90 100644
--- a/src/fs/id_mapping.rs
+++ b/src/fs/id_mapping.rs
@@ -1,5 +1,5 @@
 use char_enum::{char_enum_derive::FromChar, FromChar, FromStrError, ToChar};
-use std::{error::Error, fmt::Display, num::ParseIntError, ops::ControlFlow, str::FromStr};
+use std::{error::Error, fmt::Display, num::ParseIntError, str::FromStr};
 
 use itertools::{peek_nth, Itertools};
 
diff --git a/src/fs/mount.rs b/src/fs/mount.rs
index b43f739..577f773 100644
--- a/src/fs/mount.rs
+++ b/src/fs/mount.rs
@@ -1,4 +1,3 @@
-use char_enum::FromStrError;
 use itertools::Itertools;
 use std::{
     convert::Infallible,
@@ -100,7 +99,7 @@ impl FromStr for MountOptions {
 
 impl Display for MountOptions {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let options = self.0.iter().map(|x| x.to_string()).join(",");
+        let options = self.0.iter().map(|x| x.to_string()).join(" ");
         write!(f, "{options}")
     }
 }
@@ -902,7 +901,7 @@ mod tests {
     use crate::fs::{
         id_mapping::UntypedIdRange,
         mount::{ParseDeviceIdTypeError, ParseOptionsSourceError},
-        permission::Permissions,
+        permission::{OctalPermissions, Permissions},
     };
 
     use super::{
@@ -1252,7 +1251,14 @@ mod tests {
     fn it_works() {
         let mut options = MountOptions::default();
         options.push(MountOption::FsType(vec!["overlay"].into()));
+        options.push(MountOption::MakeDir(Some(Permissions::Octal(
+            BitFlags::from_bits(0x7777).unwrap().into(),
+        ))));
+
         let mount = Mount::new("/test", "/target", options);
-        println!("{mount}");
+        assert_eq!(
+            mount.to_string(),
+            "mount --types overlay --mkdir 7777 /test /target"
+        );
     }
 }
diff --git a/src/fs/permission.rs b/src/fs/permission.rs
index 4b92422..ab4b791 100644
--- a/src/fs/permission.rs
+++ b/src/fs/permission.rs
@@ -1,12 +1,10 @@
 use char_enum::{char_enum_derive::FromChar, AsIter, FromChar, FromStrError, ToChar};
-use enumflags2::{bitflags, BitFlag, FromBitsError};
+use enumflags2::{bitflags, BitFlag, BitFlags, FromBitsError};
 use std::{error::Error, fmt::Display, num::ParseIntError, ops::BitOr, str::FromStr};
 
-use enumflags2::BitFlags;
-
 use crate::utils::MapWhileRefExt;
 
-#[derive(Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ParseModeError(String);
 
 impl ParseModeError {
@@ -55,7 +53,7 @@ pub enum Mode {
 
 impl Display for Mode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.to_string())
+        write!(f, "{}", self)
     }
 }
 
@@ -74,7 +72,7 @@ impl FromStr for ModeFlags {
 
 impl Display for ModeFlags {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
+        write!(f, "{:X}", self.0)
     }
 }
 
@@ -417,11 +415,41 @@ impl Display for Permissions {
 mod tests {
     use std::str::FromStr;
 
-    use super::Permissions;
+    use enumflags2::BitFlags;
+
+    use crate::fs::permission::{
+        GroupId, Modes, Operator, SymbolicArgs, SymbolicMode, SymbolicPermissions,
+    };
+
+    use super::{ModeFlags, Permissions};
 
     #[test]
-    fn it_works() {
-        let a = Permissions::from_str("ug+w");
-        println!("{}", a.unwrap());
+    fn mode_flags() {
+        let flags = ModeFlags(BitFlags::all());
+        assert_eq!(flags.to_string(), "7777");
+    }
+
+    #[test]
+    fn symbolic_permissions() {
+        let sym = Permissions::from_str("ug+w").unwrap();
+        let group_sym = Permissions::from_str("g=u").unwrap();
+
+        assert_eq!(
+            sym,
+            Permissions::Symbolic(SymbolicPermissions::new(
+                Modes(GroupId::User | GroupId::Group),
+                Operator::Add,
+                SymbolicArgs::Mode(Modes(BitFlags::from(SymbolicMode::Write)))
+            ))
+        );
+
+        assert_eq!(
+            group_sym,
+            Permissions::Symbolic(SymbolicPermissions::new(
+                Modes(GroupId::Group.into()),
+                Operator::Eq,
+                SymbolicArgs::Group(Modes(BitFlags::from(GroupId::User)))
+            ))
+        );
     }
 }