diff --git a/src/structures/000_bios.rs b/src/structures/000_bios.rs
index 2bc9c17..c566d60 100644
--- a/src/structures/000_bios.rs
+++ b/src/structures/000_bios.rs
@@ -357,7 +357,7 @@ impl fmt::Display for FirmwareRevision {
 mod tests {
     use std::{prelude::v1::*, sync::OnceLock};
 
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
 
     use super::*;
     use crate::bitfield::Position;
@@ -378,20 +378,22 @@ mod tests {
             .iter()
             .filter_map(|f| if f.is_set { Some(*f.position) } else { None })
             .collect::<Vec<_>>();
-        assert_eq!(sample, result, "Positions");
+        pretty_assert_eq!(sample, result, "Positions");
 
         let sample = vec!["ISA is supported", "EISA is supported"];
         let qword = 0b0101_0000;
         let iter = Characteristics(qword).significants();
         let result = iter.map(|f| format!("{f}")).collect::<Vec<_>>();
-        assert_eq!(
-            sample, result,
+        pretty_assert_eq!(
+            sample,
+            result,
             "Significant values, default formatting ({:064b})",
             qword
         );
         let result = iter.map(|f| format!("{f:#}")).collect::<Vec<_>>();
-        assert_eq!(
-            sample, result,
+        pretty_assert_eq!(
+            sample,
+            result,
             "Significant values, alternative formatting ({:064b})",
             qword
         );
@@ -404,7 +406,7 @@ mod tests {
             .reserved()
             .map(|v| (v.description, v.range))
             .collect::<Vec<_>>();
-        assert_eq!(sample, result, "Reserved fields");
+        pretty_assert_eq!(sample, result, "Reserved fields");
     }
     #[test]
     fn characteristics_extension1() {
@@ -414,27 +416,29 @@ mod tests {
             .iter()
             .filter_map(|f| if f.is_set { Some(*f.position) } else { None })
             .collect::<Vec<_>>();
-        assert_eq!(sample, result, "Positions");
+        pretty_assert_eq!(sample, result, "Positions");
 
         let dflt_sample = vec!["ACPI is supported", "IEEE 1394 boot is supported"];
         let alt_sample = vec!["ACPI is supported", "1394 boot is supported"];
         let byte = 0b0100_0001;
         let iter = CharacteristicsExtension1(byte).significants();
         let dflt_result = iter.map(|f| format!("{f}")).collect::<Vec<_>>();
-        assert_eq!(
-            dflt_sample, dflt_result,
+        pretty_assert_eq!(
+            dflt_sample,
+            dflt_result,
             "Significant values, default formatting ({:08b})",
             byte
         );
         let alt_result = iter.map(|f| format!("{f:#}")).collect::<Vec<_>>();
-        assert_eq!(
-            alt_sample, alt_result,
+        pretty_assert_eq!(
+            alt_sample,
+            alt_result,
             "Significant values, alternative formatting ({:08b})",
             byte
         );
 
         let result = CharacteristicsExtension1(0).reserved().count();
-        assert_eq!(0, result, "Reserved fields");
+        pretty_assert_eq!(0, result, "Reserved fields");
     }
     #[test]
     fn characteristics_extension2() {
@@ -444,21 +448,23 @@ mod tests {
             .iter()
             .filter_map(|f| if f.is_set { Some(*f.position) } else { None })
             .collect::<Vec<_>>();
-        assert_eq!(sample, result, "Positions");
+        pretty_assert_eq!(sample, result, "Positions");
 
         let short_sample = vec!["UEFI is supported", "System is a virtual machine"];
         let long_sample = vec!["UEFI is supported","SMBIOS table describes a virtual machine. (If this bit is not set, no inference can be made about the virtuality of the system.)"];
         let byte = 0b0001_1000;
         let iter = CharacteristicsExtension2(byte).significants();
         let result = iter.map(|f| format!("{f}")).collect::<Vec<_>>();
-        assert_eq!(
-            short_sample, result,
+        pretty_assert_eq!(
+            short_sample,
+            result,
             "Significant values, default formatting ({:08b})",
             byte
         );
         let result = iter.map(|f| format!("{f:#}")).collect::<Vec<_>>();
-        assert_eq!(
-            long_sample, result,
+        pretty_assert_eq!(
+            long_sample,
+            result,
             "Significant values, alternative formatting ({:08b})",
             byte
         );
@@ -468,7 +474,7 @@ mod tests {
             .reserved()
             .map(|v| (v.description, v.range))
             .collect::<Vec<_>>();
-        assert_eq!(sample, result, "Reserved fields");
+        pretty_assert_eq!(sample, result, "Reserved fields");
     }
     #[test]
     fn rom_size() {
@@ -490,7 +496,7 @@ mod tests {
                 .into()
             })
             .collect();
-        assert_eq!(sample, result, "ROM Size");
+        pretty_assert_eq!(sample, result, "ROM Size");
     }
     #[test]
     fn dmi_bin_full_bios_structure() {
@@ -553,7 +559,7 @@ mod tests {
                 }
             })
             .unwrap();
-        assert_eq!(bios_sample, bios_result, "Full BIOS Struct");
+        pretty_assert_eq!(bios_sample, bios_result, "Full BIOS Struct");
     }
 
     #[test]
@@ -598,8 +604,9 @@ mod tests {
             .chain(bios_result.bios_characteristics_exttension_2.unwrap().significants())
             .map(|v| format!("{v}"))
             .collect::<Vec<_>>();
-        assert_eq!(
-            all_characteristics_sample, all_char_result,
+        pretty_assert_eq!(
+            all_characteristics_sample,
+            all_char_result,
             "Characteristics as in dmidecode tool"
         );
     }
@@ -618,12 +625,12 @@ mod tests {
                 }
             })
             .unwrap();
-        assert_eq!(
+        pretty_assert_eq!(
             bios_revision,
             format!("{}", bios_result.bios_revision.unwrap()),
             "BIOS Revision"
         );
-        assert_eq!(
+        pretty_assert_eq!(
             firmware_revision,
             format!("{}", bios_result.firmware_revision.unwrap()),
             "Firmware Revision"
@@ -643,6 +650,6 @@ mod tests {
                 }
             })
             .unwrap();
-        assert_eq!(size, bios_result.rom_size.into(), "ROM BIOS size");
+        pretty_assert_eq!(size, bios_result.rom_size.into(), "ROM BIOS size");
     }
 }
diff --git a/src/structures/008_port_connector.rs b/src/structures/008_port_connector.rs
index cc5ea1e..07f2763 100644
--- a/src/structures/008_port_connector.rs
+++ b/src/structures/008_port_connector.rs
@@ -343,7 +343,7 @@ impl fmt::Display for PortType {
 
 #[cfg(test)]
 mod test {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
     #[test]
     fn connector_type() {
@@ -360,7 +360,7 @@ mod test {
             ),
         ];
         let result = samples.iter().map(|v| Into::into(v.0)).collect::<Vec<_>>();
-        assert_eq!(
+        pretty_assert_eq!(
             samples.iter().map(|(_, v, s)| (v, (*s).into())).collect::<Vec<_>>(),
             result.iter().map(|r| (r, format!("{r}"))).collect::<Vec<_>>(),
         );
@@ -376,7 +376,7 @@ mod test {
             (0xFE, PortType::Undefined(254), "Undefined: 254"),
         ];
         let result = samples.iter().map(|v| Into::into(v.0)).collect::<Vec<_>>();
-        assert_eq!(
+        pretty_assert_eq!(
             samples.iter().map(|(_, v, s)| (v, (*s).into())).collect::<Vec<_>>(),
             result.iter().map(|r| (r, format!("{r}"))).collect::<Vec<_>>(),
         );
@@ -407,7 +407,7 @@ mod test {
             ],
         };
         let result = PortConnector::try_from(structure).unwrap();
-        assert_eq!(sample, result);
+        pretty_assert_eq!(sample, result);
     }
     #[test]
     fn dmi_bin() {
@@ -435,18 +435,18 @@ mod test {
                 _ => None,
             })
             .unwrap();
-        assert_eq!(&usb_sample, usb_result, "USB");
-        assert_eq!(
+        pretty_assert_eq!(&usb_sample, usb_result, "USB");
+        pretty_assert_eq!(
             "Access Bus (USB)",
             format!("{}", usb_result.internal_connector_type),
             "USB: Internal Connector Type"
         );
-        assert_eq!(
+        pretty_assert_eq!(
             "None",
             format!("{}", usb_result.external_connector_type),
             "USB: External Connector Type"
         );
-        assert_eq!("USB", format!("{}", usb_result.port_type), "USB: Port Type");
+        pretty_assert_eq!("USB", format!("{}", usb_result.port_type), "USB: Port Type");
 
         let rj45_sample = PortConnector {
             handle: 0x080A,
@@ -463,17 +463,17 @@ mod test {
                 _ => None,
             })
             .unwrap();
-        assert_eq!(&rj45_sample, rj45_result, "RJ-45");
-        assert_eq!(
+        pretty_assert_eq!(&rj45_sample, rj45_result, "RJ-45");
+        pretty_assert_eq!(
             "None",
             format!("{}", rj45_result.internal_connector_type),
             "RJ-45: Internal Connector Type"
         );
-        assert_eq!(
+        pretty_assert_eq!(
             "RJ-45",
             format!("{}", rj45_result.external_connector_type),
             "RJ-45: External Connector Type"
         );
-        assert_eq!("Network Port", format!("{}", rj45_result.port_type), "RJ-45: Port Type");
+        pretty_assert_eq!("Network Port", format!("{}", rj45_result.port_type), "RJ-45: Port Type");
     }
 }
diff --git a/src/structures/009_system_slots.rs b/src/structures/009_system_slots.rs
index e603dfa..3e32189 100644
--- a/src/structures/009_system_slots.rs
+++ b/src/structures/009_system_slots.rs
@@ -884,7 +884,7 @@ impl fmt::Display for SlotPitch {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
     const PRIMES: &[usize] = &[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61];
 
@@ -911,7 +911,7 @@ mod tests {
             (0xFE, SlotType::Undefined(254), "Undefined: 254", "Undefined: 254"),
         ];
         let result = samples.iter().map(|v| Into::into(v.0)).collect::<Vec<_>>();
-        assert_eq!(
+        pretty_assert_eq!(
             samples
                 .iter()
                 .map(|(_, v, s, m)| (v, (*s).into(), (*m).into()))
@@ -935,7 +935,7 @@ mod tests {
             (0xFE, SlotWidth::Undefined(254), "Undefined: 254"),
         ];
         let result = samples.iter().map(|v| Into::into(v.0)).collect::<Vec<_>>();
-        assert_eq!(
+        pretty_assert_eq!(
             samples.iter().map(|(_, v, s)| (v, (*s).into())).collect::<Vec<_>>(),
             result.iter().map(|r| (r, format!("{r}"))).collect::<Vec<_>>(),
         );
@@ -956,7 +956,7 @@ mod tests {
             (0xFE, CurrentUsage::Undefined(254), "Undefined: 254"),
         ];
         let result = samples.iter().map(|v| Into::into(v.0)).collect::<Vec<_>>();
-        assert_eq!(
+        pretty_assert_eq!(
             samples.iter().map(|(_, v, s)| (v, (*s).into())).collect::<Vec<_>>(),
             result.iter().map(|r| (r, format!("{r:#}"))).collect::<Vec<_>>(),
         );
@@ -973,7 +973,7 @@ mod tests {
             (0xFE, SlotLength::Undefined(254), "Undefined: 254"),
         ];
         let result = samples.iter().map(|v| Into::into(v.0)).collect::<Vec<_>>();
-        assert_eq!(
+        pretty_assert_eq!(
             samples.iter().map(|(_, v, s)| (v, (*s).into())).collect::<Vec<_>>(),
             result.iter().map(|r| (r, format!("{r:}"))).collect::<Vec<_>>(),
         );
@@ -989,27 +989,29 @@ mod tests {
             .iter()
             .filter_map(|f| if f.is_set { Some(*f.position) } else { None })
             .collect::<Vec<_>>();
-        assert_eq!(sample, result, "Positions");
+        pretty_assert_eq!(sample, result, "Positions");
 
         let dflt_sample = vec!["5.0 V is provided", "Modem ring resume is supported"];
         let alt_sample = vec!["Provides 5.0 volts", "PC Card slot supports Modem Ring Resume"];
         let byte = 0b1000_0010;
         let iter = SlotCharacteristics1(byte).significants();
         let dflt_result = iter.map(|f| format!("{f}")).collect::<Vec<_>>();
-        assert_eq!(
-            dflt_sample, dflt_result,
+        pretty_assert_eq!(
+            dflt_sample,
+            dflt_result,
             "Significant values, default formatting ({:08b})",
             byte
         );
         let alt_result = iter.map(|f| format!("{f:#}")).collect::<Vec<_>>();
-        assert_eq!(
-            alt_sample, alt_result,
+        pretty_assert_eq!(
+            alt_sample,
+            alt_result,
             "Significant values, alternative formatting ({:08b})",
             byte
         );
 
         let result = SlotCharacteristics1(0).reserved().count();
-        assert_eq!(0, result, "Reserved fields");
+        pretty_assert_eq!(0, result, "Reserved fields");
     }
 
     #[test]
@@ -1022,27 +1024,29 @@ mod tests {
             .iter()
             .filter_map(|f| if f.is_set { Some(*f.position) } else { None })
             .collect::<Vec<_>>();
-        assert_eq!(sample, result, "Positions");
+        pretty_assert_eq!(sample, result, "Positions");
 
         let dflt_sample = vec!["PME signal is supported", "Async/surprise removal is supported"];
         let alt_sample = vec!["PCI slot supports Power Management Event (PME#) signal","Slot supports async/surprise removal (i.e., removal without prior notification to the operating system, device driver, or applications)"];
         let byte = 0b0001_0001;
         let iter = SlotCharacteristics2(byte).significants();
         let dflt_result = iter.map(|f| format!("{f}")).collect::<Vec<_>>();
-        assert_eq!(
-            dflt_sample, dflt_result,
+        pretty_assert_eq!(
+            dflt_sample,
+            dflt_result,
             "Significant values, default formatting ({:08b})",
             byte
         );
         let alt_result = iter.map(|f| format!("{f:#}")).collect::<Vec<_>>();
-        assert_eq!(
-            alt_sample, alt_result,
+        pretty_assert_eq!(
+            alt_sample,
+            alt_result,
             "Significant values, alternative formatting ({:08b})",
             byte
         );
 
         let result = SlotCharacteristics2(0).reserved().count();
-        assert_eq!(1, result, "Reserved fields");
+        pretty_assert_eq!(1, result, "Reserved fields");
     }
 
     #[test]
@@ -1052,9 +1056,9 @@ mod tests {
             0x09, 0x11, 0x03, 0x09, 0x01, 0xB1, 0x0D, 0x04, 0x04, 0x04, 0x00, 0x04, 0x01, 0xE9, 0x05, 0xB5, 0xDF, 0x10,
         ];
         let result: Device = sample_data[0x0D..=0x11].into();
-        assert_eq!("05e9:b5:1b.7 (Width 16)", format!("{}", result), "Display trait");
+        pretty_assert_eq!("05e9:b5:1b.7 (Width 16)", format!("{}", result), "Display trait");
         let as_array: [u8; 5] = (&result).into();
-        assert_eq!([0xE9, 0x05, 0xB5, 0xDF, 0x10], as_array, "Display into [u8; 5]");
+        pretty_assert_eq!([0xE9, 0x05, 0xB5, 0xDF, 0x10], as_array, "Display into [u8; 5]");
     }
 
     #[test]
@@ -1072,7 +1076,7 @@ mod tests {
         .iter()
         .map(|v| v.to_string())
         .collect();
-        assert_eq!(display_sample, result.map(|v| format!("{v}")).collect::<Vec<_>>());
+        pretty_assert_eq!(display_sample, result.map(|v| format!("{v}")).collect::<Vec<_>>());
     }
 
     #[test]
@@ -1092,38 +1096,38 @@ mod tests {
                 let result = SystemSlots::try_from(structure);
                 match ((major, minor), result) {
                     (v, Err(e)) if ((2, 0)..(2, 1)).contains(&v) => {
-                        assert_eq!(
+                        pretty_assert_eq!(
                             "Formatted section length of structure SystemSlots with handle 666 \
                             should be 12 bytes",
                             format!("{}", e)
                         );
                     }
                     (v, Err(e)) if ((2, 1)..(2, 6)).contains(&v) => {
-                        assert_eq!(
+                        pretty_assert_eq!(
                             "Formatted section length of structure SystemSlots with handle 666 \
                             should be 13 bytes",
                             format!("{}", e)
                         );
                     }
                     (v, Err(e)) if ((2, 6)..(3, 2)).contains(&v) => {
-                        assert_eq!(
+                        pretty_assert_eq!(
                             "Formatted section length of structure SystemSlots with handle 666 \
                             should be 17 bytes",
                             format!("{}", e)
                         );
                     }
                     (v, Err(e)) if ((3, 2)..).contains(&v) => {
-                        assert_eq!(
+                        pretty_assert_eq!(
                             "Formatted section length of structure SystemSlots with handle 666 \
                             should be minimum of 17 bytes",
                             format!("{}", e)
                         );
                     }
                     (_, Err(e)) => {
-                        assert_eq!("could not convert slice to array", format!("{}", e));
+                        pretty_assert_eq!("could not convert slice to array", format!("{}", e));
                     }
                     (_, Ok(ss)) => {
-                        assert_eq!(666, ss.handle);
+                        pretty_assert_eq!(666, ss.handle);
                     }
                 }
             }
@@ -1223,7 +1227,7 @@ mod tests {
             ],
         };
         let result = SystemSlots::try_from(structure).unwrap();
-        assert_eq!(sample, result, "Sample:\n{:X?}\nResult:\n{:X?}", sample, result);
+        pretty_assert_eq!(sample, result, "Sample:\n{:X?}\nResult:\n{:X?}", sample, result);
     }
     #[test]
     fn dmi_bin() {
@@ -1240,7 +1244,7 @@ mod tests {
                 s.ok().filter(|s| matches!(s, Structure::SystemSlots(_)))
             })
             .collect::<Vec<_>>();
-        assert_eq!(4, slots.len(), "Slots count: {}. Should be 4", slots.len());
+        pretty_assert_eq!(4, slots.len(), "Slots count: {}. Should be 4", slots.len());
 
         let slot1_sample = SystemSlots {
             handle: 0x0900,
@@ -1268,7 +1272,7 @@ mod tests {
                 _ => None,
             })
             .unwrap();
-        assert_eq!(&slot1_sample, slot1_result, "Entire SystemSlots struct: Slot 1");
+        pretty_assert_eq!(&slot1_sample, slot1_result, "Entire SystemSlots struct: Slot 1");
         let slot4_sample = SystemSlots {
             handle: 0x0903,
             slot_designation: "PCIe Slot 4",
@@ -1295,6 +1299,6 @@ mod tests {
                 _ => None,
             })
             .unwrap();
-        assert_eq!(&slot4_sample, slot4_result, "Entire SystemSlots struct: Slot 4");
+        pretty_assert_eq!(&slot4_sample, slot4_result, "Entire SystemSlots struct: Slot 4");
     }
 }
diff --git a/src/structures/011_oem_strings.rs b/src/structures/011_oem_strings.rs
index 0d08db1..c61a49e 100644
--- a/src/structures/011_oem_strings.rs
+++ b/src/structures/011_oem_strings.rs
@@ -26,7 +26,7 @@ impl<'a> OemStrings<'a> {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -54,7 +54,7 @@ mod tests {
         };
         let result = OemStrings::try_from(structure).unwrap();
 
-        assert_eq!(sample, result.strings.collect::<Vec<_>>());
+        pretty_assert_eq!(sample, result.strings.collect::<Vec<_>>());
     }
 
     #[test]
@@ -98,7 +98,7 @@ mod tests {
                 _ => None,
             })
             .unwrap();
-        assert_eq!(&sample, result, "Sample\n{:?}\nResult\n{:?}", sample, result);
+        pretty_assert_eq!(&sample, result, "Sample\n{:?}\nResult\n{:?}", sample, result);
 
         let string_sample = vec![
             "Dell System",
@@ -111,6 +111,6 @@ mod tests {
             "19[1]",
             "19[1]",
         ];
-        assert_eq!(string_sample, result.strings.collect::<Vec<_>>(), "Strings");
+        pretty_assert_eq!(string_sample, result.strings.collect::<Vec<_>>(), "Strings");
     }
 }
diff --git a/src/structures/012_system_configuration_options.rs b/src/structures/012_system_configuration_options.rs
index 5f8aa45..a6a8e8d 100644
--- a/src/structures/012_system_configuration_options.rs
+++ b/src/structures/012_system_configuration_options.rs
@@ -39,7 +39,7 @@ impl<'a> SystemConfigurationOptions<'a> {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -68,7 +68,7 @@ mod tests {
         };
         let result = SystemConfigurationOptions::try_from(structure).unwrap();
 
-        assert_eq!(sample, result.strings.collect::<Vec<_>>());
+        pretty_assert_eq!(sample, result.strings.collect::<Vec<_>>());
     }
 
     #[test]
@@ -107,12 +107,12 @@ mod tests {
                 _ => None,
             })
             .unwrap();
-        assert_eq!(&sample, result, "Sample\n{:?}\nResult\n{:?}", sample, result);
+        pretty_assert_eq!(&sample, result, "Sample\n{:?}\nResult\n{:?}", sample, result);
 
         let string_sample = vec![
             "NVRAM_CLR: Clear user settable NVRAM areas and set defaults",
             "PWRD_EN: Close to enable password",
         ];
-        assert_eq!(string_sample, result.strings.collect::<Vec<_>>(), "Strings");
+        pretty_assert_eq!(string_sample, result.strings.collect::<Vec<_>>(), "Strings");
     }
 }
diff --git a/src/structures/013_bios_language.rs b/src/structures/013_bios_language.rs
index dd44d99..4879e47 100644
--- a/src/structures/013_bios_language.rs
+++ b/src/structures/013_bios_language.rs
@@ -106,7 +106,7 @@ impl BitField<'_> for LanguageFlags {
 mod tests {
     use std::{prelude::v1::*, sync::OnceLock};
 
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
 
     use super::*;
 
@@ -171,7 +171,7 @@ mod tests {
             ],
         };
         let result = InstallableLanguages::new(structure);
-        assert_eq!(sample, result.collect::<Vec<_>>(), "Installable language list");
+        pretty_assert_eq!(sample, result.collect::<Vec<_>>(), "Installable language list");
     }
 
     #[test]
@@ -203,6 +203,6 @@ mod tests {
             flags: Some(LanguageFlags([].iter().collect())),
             current_language: 1,
         };
-        assert_eq!(bios_language_sample, bios_language_result, "BIOS language structure");
+        pretty_assert_eq!(bios_language_sample, bios_language_result, "BIOS language structure");
     }
 }
diff --git a/src/structures/014_group_associations.rs b/src/structures/014_group_associations.rs
index 5f83d44..e78e9f7 100644
--- a/src/structures/014_group_associations.rs
+++ b/src/structures/014_group_associations.rs
@@ -79,7 +79,7 @@ impl Iterator for GroupItems<'_> {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -107,7 +107,7 @@ mod tests {
             },
         ];
 
-        assert_eq!(sample, result.collect::<Vec<_>>());
+        pretty_assert_eq!(sample, result.collect::<Vec<_>>());
     }
 
     #[test]
@@ -143,7 +143,7 @@ mod tests {
         };
         let result = GroupAssociations::try_from(structure).unwrap();
 
-        assert_eq!("Dual-Processor CPU Complex", result.group_name, "Group name");
-        assert_eq!(sample, result.items.collect::<Vec<_>>(), "Items");
+        pretty_assert_eq!("Dual-Processor CPU Complex", result.group_name, "Group name");
+        pretty_assert_eq!(sample, result.items.collect::<Vec<_>>(), "Items");
     }
 }
diff --git a/src/structures/015_system_event_log/log_record_format.rs b/src/structures/015_system_event_log/log_record_format.rs
index d447b73..5d19bce 100644
--- a/src/structures/015_system_event_log/log_record_format.rs
+++ b/src/structures/015_system_event_log/log_record_format.rs
@@ -543,7 +543,7 @@ impl fmt::Display for SystemManagementType {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -569,8 +569,8 @@ mod tests {
         let result = data.iter().map(|v| v.0.into()).collect::<Vec<SystemManagementType>>();
         let enum_sample = data.iter().map(|v| v.1).collect::<Vec<_>>();
         let display_sample = data.iter().map(|v| v.2).collect::<Vec<_>>();
-        assert_eq!(enum_sample, result, "Enum variants");
-        assert_eq!(
+        pretty_assert_eq!(enum_sample, result, "Enum variants");
+        pretty_assert_eq!(
             display_sample,
             result.iter().map(|v| format!("{v}")).collect::<Vec<_>>(),
             "Enum variants"
@@ -595,12 +595,12 @@ mod tests {
             (Position(36), "Available for OEM assignment".to_string()),
             (Position(38), "Available for OEM assignment".to_string()),
         ];
-        assert_eq!(
+        pretty_assert_eq!(
             significant_sample,
             pr.significants().map(|v| format!("{v}")).collect::<Vec<_>>(),
             "Significants"
         );
-        assert_eq!(
+        pretty_assert_eq!(
             reserved_sample,
             pr.iter()
                 .filter_map(|f| {
diff --git a/src/structures/015_system_event_log/mod.rs b/src/structures/015_system_event_log/mod.rs
index b64cefe..0c8711b 100644
--- a/src/structures/015_system_event_log/mod.rs
+++ b/src/structures/015_system_event_log/mod.rs
@@ -398,7 +398,7 @@ impl From<EventLogTypeDescriptor> for [u8; 2] {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -425,7 +425,7 @@ mod tests {
             (0x80, "BIOS Vendor/OEM-specific: Method 128, Address 0x12345678"),
         ];
         for (m, s) in data {
-            assert_eq!(*s, format!("{:#}", AccessMethod::new(*m, address)));
+            pretty_assert_eq!(*s, format!("{:#}", AccessMethod::new(*m, address)));
         }
     }
 
@@ -437,7 +437,7 @@ mod tests {
         let byte: u8 = 0b111;
         let ls: LogStatus = byte.into();
         let sample = vec!["Log area valid", "Log area full"];
-        assert_eq!(sample, ls.significants().map(|v| format!("{v:#}")).collect::<Vec<_>>());
+        pretty_assert_eq!(sample, ls.significants().map(|v| format!("{v:#}")).collect::<Vec<_>>());
     }
 
     #[test]
@@ -451,7 +451,7 @@ mod tests {
             (0xFF, "BIOS vendor or OEM-specific format: 255"),
         ];
         for (v, s) in data {
-            assert_eq!(*s, format!("{:#}", LogHeaderFormat::from(*v)));
+            pretty_assert_eq!(*s, format!("{:#}", LogHeaderFormat::from(*v)));
         }
     }
 
@@ -496,7 +496,7 @@ mod tests {
             },
         ];
         let result = SupportedEventLogTypeDescriptors::new(data, 2);
-        assert_eq!(sample, result.collect::<Vec<_>>());
+        pretty_assert_eq!(sample, result.collect::<Vec<_>>());
     }
 
     #[test]
@@ -522,13 +522,13 @@ mod tests {
         let access_method = AccessMethod::MemoryMappedPhysicaAddress {
             physical_address: 0xFFC40000,
         };
-        assert_eq!(access_method, result.access_method, "AccessMethod");
+        pretty_assert_eq!(access_method, result.access_method, "AccessMethod");
 
         let log_status = [Position(0)].iter().collect::<u8>().into();
-        assert_eq!(log_status, result.log_status, "LogStatus");
+        pretty_assert_eq!(log_status, result.log_status, "LogStatus");
 
         let seltd_length = result.supported_event_log_type_descriptors.clone().unwrap().count();
-        assert_eq!(27, seltd_length, "Supported Log Type Descriptors count");
+        pretty_assert_eq!(27, seltd_length, "Supported Log Type Descriptors count");
 
         let seltd_sample = [
             (T::SingleBitEccMemoryError, D::None),
@@ -570,7 +570,7 @@ mod tests {
             .clone()
             .unwrap()
             .collect::<Vec<_>>();
-        assert_eq!(seltd_sample, seltd_result, "SupportedEventLogTypeDescriptors");
+        pretty_assert_eq!(seltd_sample, seltd_result, "SupportedEventLogTypeDescriptors");
 
         let sample_bytes = seltd_sample.iter().fold(Vec::new(), |mut vec: Vec<u8>, eltd| {
             vec.push(eltd.log_type.into());
@@ -588,6 +588,6 @@ mod tests {
             log_header_format: Some(LogHeaderFormat::LogHeaderType1),
             supported_event_log_type_descriptors: Some(SupportedEventLogTypeDescriptors::new(&sample_bytes, 2)),
         };
-        assert_eq!(sample, result, "SystemEventLog");
+        pretty_assert_eq!(sample, result, "SystemEventLog");
     }
 }
diff --git a/src/structures/018_memory_error_32.rs b/src/structures/018_memory_error_32.rs
index 898096e..d7d241e 100644
--- a/src/structures/018_memory_error_32.rs
+++ b/src/structures/018_memory_error_32.rs
@@ -192,7 +192,7 @@ impl fmt::Display for ErrorOperation {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -201,7 +201,7 @@ mod tests {
 
         let sample = &["", "Other", "Unknown", "Read", "Write", "Partial write", "Undefined: 6"];
         for n in 1u8..7 {
-            assert_eq!(sample[n as usize], format!("{:#}", ErrorOperation::from(n)));
+            pretty_assert_eq!(sample[n as usize], format!("{:#}", ErrorOperation::from(n)));
         }
     }
 
@@ -218,7 +218,7 @@ mod tests {
             "Undefined: 5",
         ];
         for n in 0u8..6 {
-            assert_eq!(sample[n as usize], format!("{:#}", ErrorGranularity::from(n)));
+            pretty_assert_eq!(sample[n as usize], format!("{:#}", ErrorGranularity::from(n)));
         }
     }
 
@@ -244,7 +244,7 @@ mod tests {
             "Uncorrectable error",
         ];
         for n in 0u8..0x0E {
-            assert_eq!(sample[n as usize], format!("{:#}", ErrorType::from(n)));
+            pretty_assert_eq!(sample[n as usize], format!("{:#}", ErrorType::from(n)));
         }
     }
 
@@ -275,6 +275,6 @@ mod tests {
             error_resolution: 0x8000_0000,
         };
         let result = MemoryError32::try_from(structure).unwrap();
-        assert_eq!(sample, result);
+        pretty_assert_eq!(sample, result);
     }
 }
diff --git a/src/structures/019_memory_array_mapped_address.rs b/src/structures/019_memory_array_mapped_address.rs
index 6474b9b..b81213a 100644
--- a/src/structures/019_memory_array_mapped_address.rs
+++ b/src/structures/019_memory_array_mapped_address.rs
@@ -80,7 +80,7 @@ impl<'a> MemoryArrayMappedAddress {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -109,6 +109,6 @@ mod tests {
             extended_ending_address: Some(0),
         };
         let result = MemoryArrayMappedAddress::try_from(structure).unwrap();
-        assert_eq!(sample, result, "MemoryArrayMappedAddress");
+        pretty_assert_eq!(sample, result, "MemoryArrayMappedAddress");
     }
 }
diff --git a/src/structures/020_memory_device_mapped_address.rs b/src/structures/020_memory_device_mapped_address.rs
index e32cc34..0ad5daf 100644
--- a/src/structures/020_memory_device_mapped_address.rs
+++ b/src/structures/020_memory_device_mapped_address.rs
@@ -96,7 +96,7 @@ impl<'a> MemoryDeviceMappedAddress {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -128,6 +128,6 @@ mod tests {
             extended_ending_address: Some(0),
         };
         let result = MemoryDeviceMappedAddress::try_from(structure).unwrap();
-        assert_eq!(sample, result, "MemoryDeviceMappedAddress");
+        pretty_assert_eq!(sample, result, "MemoryDeviceMappedAddress");
     }
 }
diff --git a/src/structures/021_built_in_pointing_device.rs b/src/structures/021_built_in_pointing_device.rs
index 57effed..2e63248 100644
--- a/src/structures/021_built_in_pointing_device.rs
+++ b/src/structures/021_built_in_pointing_device.rs
@@ -154,7 +154,7 @@ impl fmt::Display for Interface {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
@@ -174,7 +174,7 @@ mod tests {
             "Optical Sensor",
         ];
         for (n, &s) in sample.iter().enumerate() {
-            assert_eq!(s, format!("{:#}", Type::from(n as u8)));
+            pretty_assert_eq!(s, format!("{:#}", Type::from(n as u8)));
         }
     }
 
@@ -194,11 +194,11 @@ mod tests {
             "ADB (Apple Desktop Bus)",
         ];
         for (n, &s) in sample.iter().enumerate() {
-            assert_eq!(s, format!("{:#}", Interface::from(n as u8)));
+            pretty_assert_eq!(s, format!("{:#}", Interface::from(n as u8)));
         }
         let sample = &["Bus mouse DB-9", "Bus mouse micro-DIN", "USB"];
         for n in 0xA0..(0xA0 + sample.len()) {
-            assert_eq!(sample[n - 0xA0], format!("{:#}", Interface::from(n as u8)));
+            pretty_assert_eq!(sample[n - 0xA0], format!("{:#}", Interface::from(n as u8)));
         }
     }
 
@@ -225,6 +225,6 @@ mod tests {
             number_of_buttons: 3,
         };
         let result = BuiltInPointingDevice::try_from(structure).unwrap();
-        assert_eq!(sample, result, "BuiltInPointingDevice");
+        pretty_assert_eq!(sample, result, "BuiltInPointingDevice");
     }
 }
diff --git a/src/structures/022_portable_battery.rs b/src/structures/022_portable_battery.rs
index ac14057..c1d4600 100644
--- a/src/structures/022_portable_battery.rs
+++ b/src/structures/022_portable_battery.rs
@@ -243,20 +243,20 @@ impl From<DesignCapacity> for u64 {
 
 #[cfg(test)]
 mod tests {
-    use pretty_assertions::assert_eq;
+    use pretty_assertions::assert_eq as pretty_assert_eq;
     use std::prelude::v1::*;
 
     #[test]
     fn manufacture_date() {
         use super::ManufactureDate;
 
-        assert_eq!("", format!("{}", ManufactureDate::new(None, None)), "Empty");
-        assert_eq!(
+        pretty_assert_eq!("", format!("{}", ManufactureDate::new(None, None)), "Empty");
+        pretty_assert_eq!(
             "07/17/2019",
             format!("{}", ManufactureDate::new(Some("07/17/2019"), None)),
             "Basic"
         );
-        assert_eq!(
+        pretty_assert_eq!(
             "2000-02-01",
             format!("{}", ManufactureDate::new(None, Some(0x2841))),
             "SBDS"
@@ -267,13 +267,13 @@ mod tests {
     fn serial_number() {
         use super::SerialNumber;
 
-        assert_eq!("", format!("{}", SerialNumber::new(None, None)), "Empty");
-        assert_eq!(
+        pretty_assert_eq!("", format!("{}", SerialNumber::new(None, None)), "Empty");
+        pretty_assert_eq!(
             "S/N 1111",
             format!("{}", SerialNumber::new(Some("S/N 1111"), None)),
             "Basic"
         );
-        assert_eq!("0xBEAF", format!("{}", SerialNumber::new(None, Some(0xBEAF))), "SBDS");
+        pretty_assert_eq!("0xBEAF", format!("{}", SerialNumber::new(None, Some(0xBEAF))), "SBDS");
     }
 
     #[test]
@@ -293,10 +293,10 @@ mod tests {
         ];
         for (n, &s) in sample.iter().enumerate() {
             let sbds = None;
-            assert_eq!(s, format!("{}", DeviceChemistry::new(n as u8, sbds)));
+            pretty_assert_eq!(s, format!("{}", DeviceChemistry::new(n as u8, sbds)));
             if n == 0x02 {
                 let sbds = Some("PbAc");
-                assert_eq!("PbAc", format!("{:#}", DeviceChemistry::new(n as u8, sbds)));
+                pretty_assert_eq!("PbAc", format!("{:#}", DeviceChemistry::new(n as u8, sbds)));
             }
         }
     }
@@ -305,10 +305,10 @@ mod tests {
     fn design_capacity() {
         use super::DesignCapacity;
 
-        assert_eq!(0u64, DesignCapacity::new(0, None).into(), "Unknown");
-        assert_eq!(0u64, DesignCapacity::new(0, Some(42)).into(), "Unknown");
-        assert_eq!(4800u64, DesignCapacity::new(4800, None).into(), "w/o multiplier");
-        assert_eq!(9600u64, DesignCapacity::new(4800, Some(2)).into(), "With multiplier");
+        pretty_assert_eq!(0u64, DesignCapacity::new(0, None).into(), "Unknown");
+        pretty_assert_eq!(0u64, DesignCapacity::new(0, Some(42)).into(), "Unknown");
+        pretty_assert_eq!(4800u64, DesignCapacity::new(4800, None).into(), "w/o multiplier");
+        pretty_assert_eq!(9600u64, DesignCapacity::new(4800, Some(2)).into(), "With multiplier");
     }
 
     #[test]
@@ -349,6 +349,6 @@ mod tests {
             oem_specific: Some(0),
         };
         let result = PortableBattery::try_from(structure).unwrap();
-        assert_eq!(sample, result, "PortableBattery");
+        pretty_assert_eq!(sample, result, "PortableBattery");
     }
 }