diff --git a/benches/bench_redirect_performance.rs b/benches/bench_redirect_performance.rs
index fa562c5a..7da25438 100644
--- a/benches/bench_redirect_performance.rs
+++ b/benches/bench_redirect_performance.rs
@@ -73,7 +73,7 @@ fn get_redirect_rules() -> Vec<NetworkFilter> {
         .map(|(index, mut rule)| {
             rule.mask.insert(NetworkFilterMask::IS_LEFT_ANCHOR);
             rule.mask.insert(NetworkFilterMask::IS_RIGHT_ANCHOR);
-            rule.hostname = Some(format!("a{}.com/bad.js", index));
+            rule.hostname = Some(format!("a{index}.com/bad.js"));
 
             rule.filter = adblock::filters::network::FilterPart::Empty;
             rule.mask.remove(NetworkFilterMask::IS_HOSTNAME_ANCHOR);
@@ -211,7 +211,7 @@ pub fn build_custom_requests(rules: Vec<NetworkFilter>) -> Vec<Request> {
                 hostname
             };
 
-            let source_url = format!("https://{}", source_hostname);
+            let source_url = format!("https://{source_hostname}");
 
             Request::new(
                 &url,
@@ -225,7 +225,7 @@ pub fn build_custom_requests(rules: Vec<NetworkFilter>) -> Vec<Request> {
 fn bench_fn(blocker: &Blocker, resources: &ResourceStorage, requests: &[Request]) {
     requests.iter().for_each(|request| {
         let block_result = blocker.check(&request, &resources);
-        assert!(block_result.redirect.is_some(), "{:?}, {:?}", request, block_result);
+        assert!(block_result.redirect.is_some(), "{request:?}, {block_result:?}");
     });
 }
 
diff --git a/examples/deserialization.rs b/examples/deserialization.rs
index 4d780405..e8e7565b 100644
--- a/examples/deserialization.rs
+++ b/examples/deserialization.rs
@@ -32,7 +32,7 @@ fn load_requests() -> Vec<RequestRuleMatch> {
         if let Ok(record) = result {
             reqs.push(record);
         } else {
-            println!("Could not parse {:?}", result);
+            println!("Could not parse {result:?}");
         }
     }
 
@@ -74,7 +74,7 @@ fn main() {
     let mut reqs_processed = 0;
     for req in requests {
         if reqs_processed % 10000 == 0 {
-            println!("{} requests processed", reqs_processed);
+            println!("{reqs_processed} requests processed");
         }
         let request = Request::new(&req.url, &req.sourceUrl, &req.r#type).unwrap();
         let checked = engine.check_network_request(&request);
@@ -111,7 +111,7 @@ fn main() {
 
     let mismatches = mismatch_expected_match + mismatch_expected_exception + mismatch_expected_pass;
     let ratio = mismatches as f32 / requests_len as f32;
-    assert!(ratio < 0.04, "Mismatch ratio was {}", ratio);
+    assert!(ratio < 0.04, "Mismatch ratio was {ratio}");
     assert!(
         false_positive_rules.len() < 3,
         "False positive rules higher than expected: {:?}",
diff --git a/examples/example.rs b/examples/example.rs
index fa6d94d9..fc2714ac 100644
--- a/examples/example.rs
+++ b/examples/example.rs
@@ -25,5 +25,5 @@ fn main() {
     ).unwrap();
     let blocker_result = engine.check_network_request(&request);
 
-    println!("Blocker result: {:?}", blocker_result);
+    println!("Blocker result: {blocker_result:?}");
 }
diff --git a/examples/use-dat.rs b/examples/use-dat.rs
index 33f0a92b..ff6ad0e4 100644
--- a/examples/use-dat.rs
+++ b/examples/use-dat.rs
@@ -27,5 +27,5 @@ fn main() {
     let checked = engine.check_network_request(&request);
     assert!(checked.filter.is_some());
     assert!(checked.exception.is_some());
-    println!("All good: {:?}", checked);
+    println!("All good: {checked:?}");
 }
diff --git a/src/blocker.rs b/src/blocker.rs
index cb0a791e..30ed677a 100644
--- a/src/blocker.rs
+++ b/src/blocker.rs
@@ -369,8 +369,8 @@ impl Blocker {
         impl<'a> std::fmt::Display for QParam<'a> {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 match self {
-                    Self::KeyOnly(k) => write!(f, "{}", k),
-                    Self::KeyValue(k, v) => write!(f, "{}={}", k, v),
+                    Self::KeyOnly(k) => write!(f, "{k}"),
+                    Self::KeyValue(k, v) => write!(f, "{k}={v}"),
                 }
             }
         }
@@ -418,7 +418,7 @@ impl Blocker {
                 let new_param_str = if p.is_empty() {
                     String::from("")
                 } else {
-                    format!("?{}", p)
+                    format!("?{p}")
                 };
                 Some(format!("{}{}{}", &url[0..i], new_param_str, &url[hash_index..]))
             } else {
@@ -1778,7 +1778,7 @@ mod blocker_tests {
             "bsft_uid", "bsft_clkid",
             "vgo_ee",
             "igshid",
-        ].iter().map(|s| format!("*$removeparam={}", s)).collect::<Vec<_>>();
+        ].iter().map(|s| format!("*$removeparam={s}")).collect::<Vec<_>>();
 
         let (network_filters, _) = parse_filters(&filters, true, Default::default());
 
@@ -1796,7 +1796,7 @@ mod blocker_tests {
             } else {
                 Some(expected.to_string())
             };
-            assert_eq!(expected, result.rewritten_url, "Filtering parameters on {} failed", original);
+            assert_eq!(expected, result.rewritten_url, "Filtering parameters on {original} failed");
         }
     }
 
diff --git a/src/cosmetic_filter_cache.rs b/src/cosmetic_filter_cache.rs
index 489b1bd9..4c4e4546 100644
--- a/src/cosmetic_filter_cache.rs
+++ b/src/cosmetic_filter_cache.rs
@@ -193,9 +193,9 @@ impl CosmeticFilterCache {
         classes.into_iter().for_each(|class| {
             let class = class.as_ref();
             if self.simple_class_rules.contains(class)
-                && !exceptions.contains(&format!(".{}", class))
+                && !exceptions.contains(&format!(".{class}"))
             {
-                selectors.push(format!(".{}", class));
+                selectors.push(format!(".{class}"));
             }
             if let Some(bucket) = self.complex_class_rules.get(class) {
                 selectors.extend(bucket.iter().filter(|sel| !exceptions.contains(*sel)).map(|s| s.to_owned()));
@@ -203,8 +203,8 @@ impl CosmeticFilterCache {
         });
         ids.into_iter().for_each(|id| {
             let id = id.as_ref();
-            if self.simple_id_rules.contains(id) && !exceptions.contains(&format!("#{}", id)) {
-                selectors.push(format!("#{}", id));
+            if self.simple_id_rules.contains(id) && !exceptions.contains(&format!("#{id}")) {
+                selectors.push(format!("#{id}"));
             }
             if let Some(bucket) = self.complex_id_rules.get(id) {
                 selectors.extend(bucket.iter().filter(|sel| !exceptions.contains(*sel)).map(|s| s.to_owned()));
diff --git a/src/engine.rs b/src/engine.rs
index d17cad99..91f258ce 100644
--- a/src/engine.rs
+++ b/src/engine.rs
@@ -280,7 +280,7 @@ mod tests {
             let request = Request::new(&url, "", "").unwrap();
             let matched_rule = engine.check_network_request(&request);
             if expected_result {
-                assert!(matched_rule.matched, "Expected match for {}", url);
+                assert!(matched_rule.matched, "Expected match for {url}");
             } else {
                 assert!(!matched_rule.matched, "Expected no match for {}, matched with {:?}", url, matched_rule.filter);
             }
@@ -310,7 +310,7 @@ mod tests {
             let request = Request::new(&url, "", "").unwrap();
             let matched_rule = engine.check_network_request(&request);
             if expected_result {
-                assert!(matched_rule.matched, "Expected match for {}", url);
+                assert!(matched_rule.matched, "Expected match for {url}");
             } else {
                 assert!(!matched_rule.matched, "Expected no match for {}, matched with {:?}", url, matched_rule.filter);
             }
@@ -336,7 +336,7 @@ mod tests {
             let request = Request::new(&url, "", "").unwrap();
             let matched_rule = engine.check_network_request(&request);
             if expected_result {
-                assert!(matched_rule.matched, "Expected match for {}", url);
+                assert!(matched_rule.matched, "Expected match for {url}");
             } else {
                 assert!(!matched_rule.matched, "Expected no match for {}, matched with {:?}", url, matched_rule.filter);
             }
@@ -363,7 +363,7 @@ mod tests {
             let request = Request::new(&url, "", "").unwrap();
             let matched_rule = engine.check_network_request(&request);
             if expected_result {
-                assert!(matched_rule.matched, "Expected match for {}", url);
+                assert!(matched_rule.matched, "Expected match for {url}");
             } else {
                 assert!(!matched_rule.matched, "Expected no match for {}, matched with {:?}", url, matched_rule.filter);
             }
@@ -397,7 +397,7 @@ mod tests {
             let request = Request::new(&url, "", "").unwrap();
             let matched_rule = deserialized_engine.check_network_request(&request);
             if expected_result {
-                assert!(matched_rule.matched, "Expected match for {}", url);
+                assert!(matched_rule.matched, "Expected match for {url}");
             } else {
                 assert!(!matched_rule.matched, "Expected no match for {}, matched with {:?}", url, matched_rule.filter);
             }
@@ -420,7 +420,7 @@ mod tests {
         let url = "http://example.com/ad-banner.gif";
         let request = Request::new(&url, "", "").unwrap();
         let matched_rule = deserialized_engine.check_network_request(&request);
-        assert!(matched_rule.matched, "Expected match for {}", url);
+        assert!(matched_rule.matched, "Expected match for {url}");
     }
 
     #[test]
@@ -440,7 +440,7 @@ mod tests {
         let url = "http://example.com/ad-banner.gif";
         let request = Request::new(&url, "", "").unwrap();
         let matched_rule = deserialized_engine.check_network_request(&request);
-        assert!(!matched_rule.matched, "Expected NO match for {}", url);
+        assert!(!matched_rule.matched, "Expected NO match for {url}");
 
         deserialized_engine.enable_tags(&["abc"]);
         deserialized_engine.deserialize(&serialized).unwrap();
@@ -448,7 +448,7 @@ mod tests {
         let url = "http://example.com/ad-banner.gif";
         let request = Request::new(&url, "", "").unwrap();
         let matched_rule = deserialized_engine.check_network_request(&request);
-        assert!(matched_rule.matched, "Expected match for {}", url);
+        assert!(matched_rule.matched, "Expected match for {url}");
     }
 
     #[test]
@@ -457,7 +457,7 @@ mod tests {
             "ad-banner",
         ], Default::default());
         let serialized = engine.serialize_raw().unwrap();
-        println!("Engine serialized: {:?}", serialized);
+        println!("Engine serialized: {serialized:?}");
         engine.deserialize(&serialized).unwrap();
     }
 
@@ -468,7 +468,7 @@ mod tests {
         ], Default::default());
         engine.use_tags(&["abc"]);
         let serialized = engine.serialize_raw().unwrap();
-        println!("Engine serialized: {:?}", serialized);
+        println!("Engine serialized: {serialized:?}");
         engine.deserialize(&serialized).unwrap();
     }
 
@@ -484,7 +484,7 @@ mod tests {
         ]);
 
         let serialized = engine.serialize_raw().unwrap();
-        println!("Engine serialized: {:?}", serialized);
+        println!("Engine serialized: {serialized:?}");
         engine.deserialize(&serialized).unwrap();
     }
 
@@ -511,14 +511,14 @@ mod tests {
         let url = "http://example.com/ad-banner.gif";
         let request = Request::new(url, "", "").unwrap();
         let matched_rule = engine.check_network_request(&request);
-        assert!(matched_rule.matched, "Expected match for {}", url);
+        assert!(matched_rule.matched, "Expected match for {url}");
         assert_eq!(matched_rule.redirect, Some("data:text/plain;base64,".to_owned()), "Expected redirect to contain resource");
 
         let url = "http://example.com/script.js";
         let request = Request::new(url, "", "").unwrap();
         let matched_rule = engine.check_network_request(&request);
-        assert!(matched_rule.matched, "Expected match for {}", url);
-        assert_eq!(matched_rule.redirect, Some(format!("data:application/javascript;base64,{}", base64::encode(format!("{}", script)))), "Expected redirect to contain resource");
+        assert!(matched_rule.matched, "Expected match for {url}");
+        assert_eq!(matched_rule.redirect, Some(format!("data:application/javascript;base64,{}", base64::encode(format!("{script}")))), "Expected redirect to contain resource");
     }
 
     #[test]
@@ -839,7 +839,7 @@ mod tests {
         engine.use_resources(resources);
 
         fn wrap_try(scriptlet_content: &str) -> String {
-            format!("try {{\n{}\n}} catch ( e ) {{ }}\n", scriptlet_content)
+            format!("try {{\n{scriptlet_content}\n}} catch ( e ) {{ }}\n")
         }
 
         assert_eq!(engine.url_cosmetic_resources("https://sub1.example.com").injected_script, wrap_try("refresh-defuser"));
diff --git a/src/filters/network.rs b/src/filters/network.rs
index c2157e84..b2ad565b 100644
--- a/src/filters/network.rs
+++ b/src/filters/network.rs
@@ -1228,7 +1228,7 @@ pub(crate) fn compile_regex(
             // Should match start or end of url
             let left_anchor = if is_left_anchor { "^" } else { "" };
             let right_anchor = if is_right_anchor { "$" } else { "" };
-            let filter = format!("{}{}{}", left_anchor, repl, right_anchor);
+            let filter = format!("{left_anchor}{repl}{right_anchor}");
 
             escaped_patterns.push(filter);
         }
@@ -2589,7 +2589,7 @@ mod parse_tests {
         ];
 
         for option in options {
-            let filter = NetworkFilter::parse(&format!("||foo.com${}", option), true, Default::default());
+            let filter = NetworkFilter::parse(&format!("||foo.com${option}"), true, Default::default());
             assert!(filter.err().is_some());
         }
     }
@@ -2648,7 +2648,7 @@ mod parse_tests {
         for option in options {
             // positive
             {
-                let filter = NetworkFilter::parse(&format!("||foo.com${}", option), true, Default::default()).unwrap();
+                let filter = NetworkFilter::parse(&format!("||foo.com${option}"), true, Default::default()).unwrap();
                 let mut defaults = default_network_filter_breakdown();
                 defaults.hostname = Some(String::from("foo.com"));
                 defaults.is_hostname_anchor = true;
@@ -2661,7 +2661,7 @@ mod parse_tests {
 
             {
                 let filter =
-                    NetworkFilter::parse(&format!("||foo.com$object,{}", option), true, Default::default()).unwrap();
+                    NetworkFilter::parse(&format!("||foo.com$object,{option}"), true, Default::default()).unwrap();
                 let mut defaults = default_network_filter_breakdown();
                 defaults.hostname = Some(String::from("foo.com"));
                 defaults.is_hostname_anchor = true;
@@ -2675,7 +2675,7 @@ mod parse_tests {
 
             {
                 let filter =
-                    NetworkFilter::parse(&format!("||foo.com$domain=bar.com,{}", option), true, Default::default())
+                    NetworkFilter::parse(&format!("||foo.com$domain=bar.com,{option}"), true, Default::default())
                         .unwrap();
                 let mut defaults = default_network_filter_breakdown();
                 defaults.hostname = Some(String::from("foo.com"));
@@ -2690,7 +2690,7 @@ mod parse_tests {
 
             // negative
             {
-                let filter = NetworkFilter::parse(&format!("||foo.com$~{}", option), true, Default::default()).unwrap();
+                let filter = NetworkFilter::parse(&format!("||foo.com$~{option}"), true, Default::default()).unwrap();
                 let mut defaults = default_network_filter_breakdown();
                 defaults.hostname = Some(String::from("foo.com"));
                 defaults.is_hostname_anchor = true;
@@ -2703,7 +2703,7 @@ mod parse_tests {
 
             {
                 let filter =
-                    NetworkFilter::parse(&format!("||foo.com${},~{}", option, option), true, Default::default())
+                    NetworkFilter::parse(&format!("||foo.com${option},~{option}"), true, Default::default())
                         .unwrap();
                 let mut defaults = default_network_filter_breakdown();
                 defaults.hostname = Some(String::from("foo.com"));
@@ -2879,11 +2879,7 @@ mod match_tests {
 
         assert!(
             network_filter.matches_test(&request) == matching,
-            "Expected match={} for {} {:?} on {}",
-            matching,
-            filter,
-            network_filter,
-            url
+            "Expected match={matching} for {filter} {network_filter:?} on {url}"
         );
     }
 
@@ -2893,11 +2889,7 @@ mod match_tests {
 
         assert!(
             network_filter.matches_test(&request) == matching,
-            "Expected match={} for {} {:?} on {}",
-            matching,
-            filter,
-            network_filter,
-            url
+            "Expected match={matching} for {filter} {network_filter:?} on {url}"
         );
     }
 
@@ -3065,9 +3057,7 @@ mod match_tests {
             .unwrap();
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
         {
@@ -3082,9 +3072,7 @@ mod match_tests {
             .unwrap();
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
     }
@@ -3274,9 +3262,7 @@ mod match_tests {
             let request = request::Request::new(url, source, "").unwrap();
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
         {
@@ -3288,9 +3274,7 @@ mod match_tests {
             let request = request::Request::new(url, source, "xmlhttprequest").unwrap();
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
         //
@@ -3302,9 +3286,7 @@ mod match_tests {
             let request = request::Request::new(url, source, "stylesheet").unwrap();
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
     }
@@ -3341,9 +3323,7 @@ mod match_tests {
             let request = request::Request::new(url, source, "script").unwrap();
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
         {
@@ -3354,9 +3334,7 @@ mod match_tests {
             let request = request::Request::new(url, source, "script").unwrap();
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
     }
@@ -3372,9 +3350,7 @@ mod match_tests {
             assert!(!request.is_third_party);
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
         {
@@ -3386,9 +3362,7 @@ mod match_tests {
             assert!(!request.is_third_party);
             assert!(
                 network_filter.matches_test(&request) == true,
-                "Expected match for {} on {}",
-                filter,
-                url
+                "Expected match for {filter} on {url}"
             );
         }
     }
diff --git a/src/resources/mod.rs b/src/resources/mod.rs
index 0c99337d..30239de3 100644
--- a/src/resources/mod.rs
+++ b/src/resources/mod.rs
@@ -241,7 +241,7 @@ impl MimeType {
                 "xml" => MimeType::TextXml,
                 _ => {
                     #[cfg(test)]
-                    eprintln!("Unrecognized file extension on: {:?}", resource_path);
+                    eprintln!("Unrecognized file extension on: {resource_path:?}");
                     MimeType::Unknown
                 }
             }
@@ -325,7 +325,7 @@ impl From<MimeType> for &str {
 impl std::fmt::Display for MimeType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s: &str = self.into();
-        write!(f, "{}", s)
+        write!(f, "{s}")
     }
 }
 
diff --git a/src/resources/resource_storage.rs b/src/resources/resource_storage.rs
index 58aa8529..1d7464b1 100644
--- a/src/resources/resource_storage.rs
+++ b/src/resources/resource_storage.rs
@@ -67,7 +67,7 @@ fn stringify_arg<const QUOTED: bool>(arg: &str) -> String {
                 start = index + 1;
             }
             if escape == b'u' {
-                output.extend_from_slice(format!("{:04x}", ch).as_bytes());
+                output.extend_from_slice(format!("{ch:04x}").as_bytes());
             }
         }
         output.extend_from_slice(&string.as_bytes()[start ..]);
@@ -122,7 +122,7 @@ impl ResourceStorage {
                 .add_resource(resource)
                 .unwrap_or_else(|_e| {
                     #[cfg(test)]
-                    eprintln!("Failed to add resource: {:?}", _e)
+                    eprintln!("Failed to add resource: {_e:?}")
                 })
         });
 
@@ -365,7 +365,7 @@ static TEMPLATE_ARGUMENT_RE: [Lazy<Regex>; 9] = [
 ];
 
 fn template_argument_regex(i: usize) -> Regex {
-    Regex::new(&format!(r"\{{\{{{}\}}\}}", i)).unwrap()
+    Regex::new(&format!(r"\{{\{{{i}\}}\}}")).unwrap()
 }
 
 /// Omit the 0th element of `args` (the scriptlet name) when calling this method.
@@ -386,7 +386,7 @@ fn with_js_extension(scriptlet_name: &str) -> String {
     if scriptlet_name.ends_with(".js") {
         scriptlet_name.to_string()
     } else {
-        format!("{}.js", scriptlet_name)
+        format!("{scriptlet_name}.js")
     }
 }
 
@@ -966,12 +966,12 @@ mod scriptlet_storage_tests {
                 if ident.len() > 2 {
                     assert_eq!(
                         resources.get_scriptlet_resources([(*ident, perm)]),
-                        format!("try {{\n{}\n}} catch ( e ) {{ }}\n", ident),
+                        format!("try {{\n{ident}\n}} catch ( e ) {{ }}\n"),
                     );
                 } else {
                     assert_eq!(
                         resources.get_scriptlet_resources([(*ident, perm)]),
-                        format!("try {{\nperm{}\n}} catch ( e ) {{ }}\n", ident),
+                        format!("try {{\nperm{ident}\n}} catch ( e ) {{ }}\n"),
                     );
                 }
             }
diff --git a/src/url_parser/parser.rs b/src/url_parser/parser.rs
index 4653d886..1c84de94 100644
--- a/src/url_parser/parser.rs
+++ b/src/url_parser/parser.rs
@@ -529,10 +529,10 @@ impl Parser {
         }
 
         if host_str.is_ascii() {
-            write!(&mut self.serialization, "{}", host_str).unwrap();
+            write!(&mut self.serialization, "{host_str}").unwrap();
         } else {
             let encoded = idna::domain_to_ascii(host_str)?;
-            write!(&mut self.serialization, "{}", encoded).unwrap();
+            write!(&mut self.serialization, "{encoded}").unwrap();
         }
 
         let host_end = self.serialization.len();
diff --git a/tests/deserialization.rs b/tests/deserialization.rs
index 4ab9c9d0..fa0f2456 100644
--- a/tests/deserialization.rs
+++ b/tests/deserialization.rs
@@ -31,7 +31,7 @@ fn load_requests() -> Vec<RequestRuleMatch> {
             let record: RequestRuleMatch = result.expect("WAT");
             reqs.push(record);
         } else {
-            println!("Could not parse {:?}", result);
+            println!("Could not parse {result:?}");
         }
     }
 
@@ -66,7 +66,7 @@ fn check_works_same_after_deserialization() {
     let mut false_negative_exceptions: HashMap<String, (String, String, String)> = HashMap::new();
     let mut reqs_processed = 0;
     for req in requests {
-        print!("{} ", reqs_processed);
+        print!("{reqs_processed} ");
         let request = Request::new(&req.url, &req.sourceUrl, &req.r#type).unwrap();
         let checked = engine.check_network_request(&request);
         if req.blocked == 1 && checked.matched != true {
@@ -102,7 +102,7 @@ fn check_works_same_after_deserialization() {
 
     let mismatches = mismatch_expected_match + mismatch_expected_exception + mismatch_expected_pass;
     let ratio = mismatches as f32 / requests_len as f32;
-    assert!(ratio < 0.04, "Mismatch ratio was {}", ratio);
+    assert!(ratio < 0.04, "Mismatch ratio was {ratio}");
     assert!(
         false_positive_rules.len() < 3,
         "False positive rules higher than expected: {:?}",
diff --git a/tests/legacy_harness.rs b/tests/legacy_harness.rs
index 0d20645e..b58c68d0 100644
--- a/tests/legacy_harness.rs
+++ b/tests/legacy_harness.rs
@@ -23,8 +23,7 @@ mod legacy_test_filters {
 
         assert_eq!(
             filter.mask, expected_filter_mask,
-            "Filter {} mask doesn't match expectation",
-            raw_filter
+            "Filter {raw_filter} mask doesn't match expectation"
         );
 
         let filter_string = filter.filter.string_view();
@@ -499,7 +498,7 @@ mod legacy_check_options {
         for (url, source_url, request_type, expectation) in tests {
             let request = Request::new(url, source_url, request_type).unwrap();
             assert!(engine.check_network_request(&request).matched == *expectation,
-                "Expected match = {} for {} from {} typed {} against {:?}", expectation, url, source_url, request_type, rules)
+                "Expected match = {expectation} for {url} from {source_url} typed {request_type} against {rules:?}")
         }
     }
 
diff --git a/tests/live.rs b/tests/live.rs
index 578738ef..ddfc820d 100644
--- a/tests/live.rs
+++ b/tests/live.rs
@@ -34,7 +34,7 @@ fn load_requests() -> Vec<RequestRuleMatch> {
                 blocked: record.blocked,
             });
         } else {
-            println!("Could not parse {:?}", result);
+            println!("Could not parse {result:?}");
         }
     }
 
@@ -69,8 +69,7 @@ static ALL_FILTERS: once_cell::sync::Lazy<std::sync::Mutex<adblock::lists::Filte
             const DEFAULT_LISTS_URL: &'static str = "https://raw.githubusercontent.com/brave/adblock-resources/master/filter_lists/list_catalog.json";
 
             println!(
-                "Downloading list of filter lists from '{}'",
-                DEFAULT_LISTS_URL
+                "Downloading list of filter lists from '{DEFAULT_LISTS_URL}'"
             );
             let default_catalog: Vec<RemoteFilterCatalogEntry> = async {
                 let body = reqwest::get(DEFAULT_LISTS_URL)
@@ -281,7 +280,7 @@ fn check_live_brave_deserialized_file() {
     let requests = load_requests();
 
     for req in requests {
-        println!("Checking {:?}", req);
+        println!("Checking {req:?}");
         let checked = engine.check_network_request(&Request::new(&req.url, &req.sourceUrl, &req.r#type).unwrap());
         assert_eq!(
             checked.matched, req.blocked,
diff --git a/tests/matching.rs b/tests/matching.rs
index 9cbf28b7..1e89daf2 100644
--- a/tests/matching.rs
+++ b/tests/matching.rs
@@ -67,8 +67,7 @@ fn check_filter_matching() {
             let network_filter_res = NetworkFilter::parse(&filter, true, opts);
             assert!(
                 network_filter_res.is_ok(),
-                "Could not parse filter {}",
-                filter
+                "Could not parse filter {filter}"
             );
             let network_filter = network_filter_res.unwrap();
 
@@ -111,8 +110,7 @@ fn check_engine_matching() {
             let network_filter_res = NetworkFilter::parse(&filter, true, opts);
             assert!(
                 network_filter_res.is_ok(),
-                "Could not parse filter {}",
-                filter
+                "Could not parse filter {filter}"
             );
             let network_filter = network_filter_res.unwrap();
 
diff --git a/tests/ublock-coverage.rs b/tests/ublock-coverage.rs
index a0c3b0a3..c69c38af 100644
--- a/tests/ublock-coverage.rs
+++ b/tests/ublock-coverage.rs
@@ -33,7 +33,7 @@ fn load_requests() -> Vec<RequestRuleMatch> {
             let record: RequestRuleMatch = result.unwrap();
             reqs.push(record);
         } else {
-            println!("Could not parse {:?}", result);
+            println!("Could not parse {result:?}");
         }
     }
 
@@ -247,18 +247,15 @@ fn check_matching_equivalent() {
     assert!(ratio < 0.01);
     assert!(
         false_positive_rules.len() < 3,
-        "False positive rules higher than expected: {:?}",
-        false_positive_rules
+        "False positive rules higher than expected: {false_positive_rules:?}"
     );
     assert!(
         false_negative_rules.len() < 3,
-        "False negative rules higher than expected: {:?}",
-        false_negative_rules
+        "False negative rules higher than expected: {false_negative_rules:?}"
     );
     assert!(
         false_negative_exceptions.len() < 3,
-        "False negative exceptions higher than expected: {:?}",
-        false_negative_exceptions
+        "False negative exceptions higher than expected: {false_negative_exceptions:?}"
     );
 }