diff --git a/Cargo.toml b/Cargo.toml
index fa5f20ca..b0460960 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,12 +35,11 @@ path = []
 [dev-dependencies]
 # Property testing for interner getters and setters.
 quickcheck = { version = "1.0.3", default-features = false }
-quickcheck_macros = "1.0.0"
 
 # Check that crate versions are properly updated in documentation and code when
 # bumping the version.
 [dev-dependencies.version-sync]
-version = "0.9.3"
+version = "0.9.5"
 default-features = false
 features = ["markdown_deps_updated", "html_root_url_updated"]
 
diff --git a/src/bytes.rs b/src/bytes.rs
index 3fd0d01f..63412fc5 100644
--- a/src/bytes.rs
+++ b/src/bytes.rs
@@ -896,7 +896,7 @@ where
 #[cfg(test)]
 #[allow(clippy::needless_pass_by_value)]
 mod tests {
-    use quickcheck_macros::quickcheck;
+    use quickcheck::quickcheck;
 
     use super::SymbolTable;
 
@@ -960,45 +960,41 @@ mod tests {
         assert_eq!(sym, table.intern(&b"abc"[..]).unwrap());
     }
 
-    #[quickcheck]
-    fn intern_twice_symbol_equality(bytes: Vec<u8>) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(bytes.clone()).unwrap();
-        let sym_again = table.intern(bytes).unwrap();
-        sym == sym_again
-    }
+    quickcheck! {
+        fn intern_twice_symbol_equality(bytes: Vec<u8>) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(bytes.clone()).unwrap();
+            let sym_again = table.intern(bytes).unwrap();
+            sym == sym_again
+        }
 
-    #[quickcheck]
-    fn intern_get_roundtrip(bytes: Vec<u8>) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(bytes.clone()).unwrap();
-        let retrieved_bytes = table.get(sym).unwrap();
-        bytes == retrieved_bytes
-    }
+        fn intern_get_roundtrip(bytes: Vec<u8>) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(bytes.clone()).unwrap();
+            let retrieved_bytes = table.get(sym).unwrap();
+            bytes == retrieved_bytes
+        }
 
-    #[quickcheck]
-    fn table_contains_sym(bytes: Vec<u8>) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(bytes).unwrap();
-        table.contains(sym)
-    }
+        fn table_contains_sym(bytes: Vec<u8>) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(bytes).unwrap();
+            table.contains(sym)
+        }
 
-    #[quickcheck]
-    fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
-        let table = SymbolTable::new();
-        !table.contains(sym.into())
-    }
+        fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
+            let table = SymbolTable::new();
+            !table.contains(sym.into())
+        }
 
-    #[quickcheck]
-    fn empty_table_does_not_report_any_interned_byte_strings(bytes: Vec<u8>) -> bool {
-        let table = SymbolTable::new();
-        !table.is_interned(bytes.as_slice())
-    }
+        fn empty_table_does_not_report_any_interned_byte_strings(bytes: Vec<u8>) -> bool {
+            let table = SymbolTable::new();
+            !table.is_interned(bytes.as_slice())
+        }
 
-    #[quickcheck]
-    fn table_reports_interned_byte_strings_as_interned(bytes: Vec<u8>) -> bool {
-        let mut table = SymbolTable::new();
-        table.intern(bytes.clone()).unwrap();
-        table.is_interned(bytes.as_slice())
+        fn table_reports_interned_byte_strings_as_interned(bytes: Vec<u8>) -> bool {
+            let mut table = SymbolTable::new();
+            table.intern(bytes.clone()).unwrap();
+            table.is_interned(bytes.as_slice())
+        }
     }
 }
diff --git a/src/cstr.rs b/src/cstr.rs
index 22d15608..f77cf8ad 100644
--- a/src/cstr.rs
+++ b/src/cstr.rs
@@ -926,7 +926,7 @@ where
 mod tests {
     use std::ffi::{CStr, CString};
 
-    use quickcheck_macros::quickcheck;
+    use quickcheck::quickcheck;
 
     use super::SymbolTable;
 
@@ -1012,45 +1012,41 @@ mod tests {
         );
     }
 
-    #[quickcheck]
-    fn intern_twice_symbol_equality(cstring: CString) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(cstring.clone()).unwrap();
-        let sym_again = table.intern(cstring).unwrap();
-        sym == sym_again
-    }
+    quickcheck! {
+        fn intern_twice_symbol_equality(cstring: CString) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(cstring.clone()).unwrap();
+            let sym_again = table.intern(cstring).unwrap();
+            sym == sym_again
+        }
 
-    #[quickcheck]
-    fn intern_get_roundtrip(cstring: CString) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(cstring.clone()).unwrap();
-        let retrieved_c_string = table.get(sym).unwrap();
-        &*cstring == retrieved_c_string
-    }
+        fn intern_get_roundtrip(cstring: CString) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(cstring.clone()).unwrap();
+            let retrieved_c_string = table.get(sym).unwrap();
+            &*cstring == retrieved_c_string
+        }
 
-    #[quickcheck]
-    fn table_contains_sym(cstring: CString) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(cstring).unwrap();
-        table.contains(sym)
-    }
+        fn table_contains_sym(cstring: CString) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(cstring).unwrap();
+            table.contains(sym)
+        }
 
-    #[quickcheck]
-    fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
-        let table = SymbolTable::new();
-        !table.contains(sym.into())
-    }
+        fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
+            let table = SymbolTable::new();
+            !table.contains(sym.into())
+        }
 
-    #[quickcheck]
-    fn empty_table_does_not_report_any_interned_c_strings(cstring: CString) -> bool {
-        let table = SymbolTable::new();
-        !table.is_interned(cstring.as_c_str())
-    }
+        fn empty_table_does_not_report_any_interned_c_strings(cstring: CString) -> bool {
+            let table = SymbolTable::new();
+            !table.is_interned(cstring.as_c_str())
+        }
 
-    #[quickcheck]
-    fn table_reports_interned_c_strings_as_interned(cstring: CString) -> bool {
-        let mut table = SymbolTable::new();
-        table.intern(cstring.clone()).unwrap();
-        table.is_interned(cstring.as_c_str())
+        fn table_reports_interned_c_strings_as_interned(cstring: CString) -> bool {
+            let mut table = SymbolTable::new();
+            table.intern(cstring.clone()).unwrap();
+            table.is_interned(cstring.as_c_str())
+        }
     }
 }
diff --git a/src/osstr.rs b/src/osstr.rs
index 871ff2a0..bd5795b4 100644
--- a/src/osstr.rs
+++ b/src/osstr.rs
@@ -926,7 +926,7 @@ where
 mod tests {
     use std::ffi::{OsStr, OsString};
 
-    use quickcheck_macros::quickcheck;
+    use quickcheck::quickcheck;
 
     use super::SymbolTable;
 
@@ -990,45 +990,41 @@ mod tests {
         assert_eq!(sym, table.intern(OsStr::new("abc")).unwrap());
     }
 
-    #[quickcheck]
-    fn intern_twice_symbol_equality(os_string: OsString) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(os_string.clone()).unwrap();
-        let sym_again = table.intern(os_string).unwrap();
-        sym == sym_again
-    }
+    quickcheck! {
+        fn intern_twice_symbol_equality(os_string: OsString) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(os_string.clone()).unwrap();
+            let sym_again = table.intern(os_string).unwrap();
+            sym == sym_again
+        }
 
-    #[quickcheck]
-    fn intern_get_roundtrip(os_string: OsString) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(os_string.clone()).unwrap();
-        let retrieved_os_string = table.get(sym).unwrap();
-        &*os_string == retrieved_os_string
-    }
+        fn intern_get_roundtrip(os_string: OsString) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(os_string.clone()).unwrap();
+            let retrieved_os_string = table.get(sym).unwrap();
+            &*os_string == retrieved_os_string
+        }
 
-    #[quickcheck]
-    fn table_contains_sym(os_string: OsString) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(os_string).unwrap();
-        table.contains(sym)
-    }
+        fn table_contains_sym(os_string: OsString) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(os_string).unwrap();
+            table.contains(sym)
+        }
 
-    #[quickcheck]
-    fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
-        let table = SymbolTable::new();
-        !table.contains(sym.into())
-    }
+        fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
+            let table = SymbolTable::new();
+            !table.contains(sym.into())
+        }
 
-    #[quickcheck]
-    fn empty_table_does_not_report_any_interned_os_strings(os_string: OsString) -> bool {
-        let table = SymbolTable::new();
-        !table.is_interned(os_string.as_os_str())
-    }
+        fn empty_table_does_not_report_any_interned_os_strings(os_string: OsString) -> bool {
+            let table = SymbolTable::new();
+            !table.is_interned(os_string.as_os_str())
+        }
 
-    #[quickcheck]
-    fn table_reports_interned_os_strs_as_interned(os_string: OsString) -> bool {
-        let mut table = SymbolTable::new();
-        table.intern(os_string.clone()).unwrap();
-        table.is_interned(os_string.as_os_str())
+        fn table_reports_interned_os_strs_as_interned(os_string: OsString) -> bool {
+            let mut table = SymbolTable::new();
+            table.intern(os_string.clone()).unwrap();
+            table.is_interned(os_string.as_os_str())
+        }
     }
 }
diff --git a/src/path.rs b/src/path.rs
index 7baf0196..8f3ed1c3 100644
--- a/src/path.rs
+++ b/src/path.rs
@@ -926,7 +926,7 @@ where
 mod tests {
     use std::path::{Path, PathBuf};
 
-    use quickcheck_macros::quickcheck;
+    use quickcheck::quickcheck;
 
     use super::SymbolTable;
 
@@ -990,45 +990,41 @@ mod tests {
         assert_eq!(sym, table.intern(Path::new("abc")).unwrap());
     }
 
-    #[quickcheck]
-    fn intern_twice_symbol_equality(path: PathBuf) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(path.clone()).unwrap();
-        let sym_again = table.intern(path).unwrap();
-        sym == sym_again
-    }
+    quickcheck! {
+        fn intern_twice_symbol_equality(path: PathBuf) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(path.clone()).unwrap();
+            let sym_again = table.intern(path).unwrap();
+            sym == sym_again
+        }
 
-    #[quickcheck]
-    fn intern_get_roundtrip(path: PathBuf) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(path.clone()).unwrap();
-        let retrieved_path = table.get(sym).unwrap();
-        &*path == retrieved_path
-    }
+        fn intern_get_roundtrip(path: PathBuf) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(path.clone()).unwrap();
+            let retrieved_path = table.get(sym).unwrap();
+            &*path == retrieved_path
+        }
 
-    #[quickcheck]
-    fn table_contains_sym(path: PathBuf) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(path).unwrap();
-        table.contains(sym)
-    }
+        fn table_contains_sym(path: PathBuf) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(path).unwrap();
+            table.contains(sym)
+        }
 
-    #[quickcheck]
-    fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
-        let table = SymbolTable::new();
-        !table.contains(sym.into())
-    }
+        fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
+            let table = SymbolTable::new();
+            !table.contains(sym.into())
+        }
 
-    #[quickcheck]
-    fn empty_table_does_not_report_any_interned_paths(path: PathBuf) -> bool {
-        let table = SymbolTable::new();
-        !table.is_interned(path.as_path())
-    }
+        fn empty_table_does_not_report_any_interned_paths(path: PathBuf) -> bool {
+            let table = SymbolTable::new();
+            !table.is_interned(path.as_path())
+        }
 
-    #[quickcheck]
-    fn table_reports_interned_paths_as_interned(path: PathBuf) -> bool {
-        let mut table = SymbolTable::new();
-        table.intern(path.clone()).unwrap();
-        table.is_interned(path.as_path())
+        fn table_reports_interned_paths_as_interned(path: PathBuf) -> bool {
+            let mut table = SymbolTable::new();
+            table.intern(path.clone()).unwrap();
+            table.is_interned(path.as_path())
+        }
     }
 }
diff --git a/src/str.rs b/src/str.rs
index 31e0cc68..902eee26 100644
--- a/src/str.rs
+++ b/src/str.rs
@@ -834,7 +834,7 @@ where
 #[cfg(test)]
 #[allow(clippy::needless_pass_by_value)]
 mod tests {
-    use quickcheck_macros::quickcheck;
+    use quickcheck::quickcheck;
 
     use super::SymbolTable;
 
@@ -898,45 +898,41 @@ mod tests {
         assert_eq!(sym, table.intern("abc").unwrap());
     }
 
-    #[quickcheck]
-    fn intern_twice_symbol_equality(string: String) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(string.clone()).unwrap();
-        let sym_again = table.intern(string).unwrap();
-        sym == sym_again
-    }
+    quickcheck! {
+        fn intern_twice_symbol_equality(string: String) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(string.clone()).unwrap();
+            let sym_again = table.intern(string).unwrap();
+            sym == sym_again
+        }
 
-    #[quickcheck]
-    fn intern_get_roundtrip(string: String) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(string.clone()).unwrap();
-        let retrieved_str = table.get(sym).unwrap();
-        string == retrieved_str
-    }
+        fn intern_get_roundtrip(string: String) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(string.clone()).unwrap();
+            let retrieved_str = table.get(sym).unwrap();
+            string == retrieved_str
+        }
 
-    #[quickcheck]
-    fn table_contains_sym(string: String) -> bool {
-        let mut table = SymbolTable::new();
-        let sym = table.intern(string).unwrap();
-        table.contains(sym)
-    }
+        fn table_contains_sym(string: String) -> bool {
+            let mut table = SymbolTable::new();
+            let sym = table.intern(string).unwrap();
+            table.contains(sym)
+        }
 
-    #[quickcheck]
-    fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
-        let table = SymbolTable::new();
-        !table.contains(sym.into())
-    }
+        fn table_does_not_contain_missing_symbol_ids(sym: u32) -> bool {
+            let table = SymbolTable::new();
+            !table.contains(sym.into())
+        }
 
-    #[quickcheck]
-    fn empty_table_does_not_report_any_interned_strings(string: String) -> bool {
-        let table = SymbolTable::new();
-        !table.is_interned(string.as_str())
-    }
+        fn empty_table_does_not_report_any_interned_strings(string: String) -> bool {
+            let table = SymbolTable::new();
+            !table.is_interned(string.as_str())
+        }
 
-    #[quickcheck]
-    fn table_reports_interned_strings_as_interned(string: String) -> bool {
-        let mut table = SymbolTable::new();
-        table.intern(string.clone()).unwrap();
-        table.is_interned(string.as_str())
+        fn table_reports_interned_strings_as_interned(string: String) -> bool {
+            let mut table = SymbolTable::new();
+            table.intern(string.clone()).unwrap();
+            table.is_interned(string.as_str())
+        }
     }
 }