--- a/gfx/wr/wrench/src/reftest.rs
+++ b/gfx/wr/wrench/src/reftest.rs
@@ -144,31 +144,20 @@ impl Reftest {
                     false
                 } else {
                     true
                 }
             }
         }
     }
 
-    /// Check the negative case (expecting inequality) and report details if same
-    fn check_and_report_inequality_failure(
-        &self,
-        comparison: ReftestImageComparison,
-    ) -> bool {
-        match comparison {
-            ReftestImageComparison::Equal => {
-                println!("REFTEST TEST-UNEXPECTED-FAIL | {} | image comparison", self);
-                println!("REFTEST TEST-END | {}", self);
-                false
-            }
-            ReftestImageComparison::NotEqual { .. } => {
-                true
-            }
-        }
+    /// Report details of the negative case
+    fn report_unexpected_equality(&self) {
+        println!("REFTEST TEST-UNEXPECTED-FAIL | {} | image comparison", self);
+        println!("REFTEST TEST-END | {}", self);
     }
 }
 
 impl Display for Reftest {
     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
         let paths: Vec<String> = self.test.iter().map(|t| t.display().to_string()).collect();
         write!(
             f,
@@ -699,17 +688,25 @@ impl<'a> ReftestHarness<'a> {
                     &test,
                     &reference,
                 )
             }
             ReftestOp::NotEqual => {
                 // Ensure that the final image *doesn't* match the reference
                 let test = images.pop().unwrap();
                 let comparison = test.compare(&reference);
-                t.check_and_report_inequality_failure(comparison)
+                match comparison {
+                    ReftestImageComparison::Equal => {
+                        t.report_unexpected_equality();
+                        false
+                    }
+                    ReftestImageComparison::NotEqual { .. } => {
+                        true
+                    }
+                }
             }
             ReftestOp::Accurate => {
                 // Ensure that *all* images match the reference
                 for test in images.drain(..) {
                     let comparison = test.compare(&reference);
 
                     if !t.check_and_report_equality_failure(
                         comparison,
@@ -719,24 +716,28 @@ impl<'a> ReftestHarness<'a> {
                         return false;
                     }
                 }
 
                 true
             }
             ReftestOp::Inaccurate => {
                 // Ensure that at least one of the images doesn't match the reference
-                let mut found_mismatch = false;
+                let all_same = images.iter().all(|image| {
+                    match image.compare(&reference) {
+                        ReftestImageComparison::Equal => true,
+                        ReftestImageComparison::NotEqual { .. } => false,
+                    }
+                });
 
-                for test in images.drain(..) {
-                    let comparison = test.compare(&reference);
-                    found_mismatch |= t.check_and_report_inequality_failure(comparison);
+                if all_same {
+                    t.report_unexpected_equality();
                 }
 
-                found_mismatch
+                !all_same
             }
         }
     }
 
     fn load_image(&mut self, filename: &Path, format: ImageFormat) -> ReftestImage {
         let file = BufReader::new(File::open(filename).unwrap());
         let img_raw = load_piston_image(file, format).unwrap();
         let img = img_raw.flipv().to_rgba();