diff --git a/src/iter.rs b/src/iter.rs
index 1210fc0..c8c97fc 100644
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -79,7 +79,12 @@ where
     }
 
     fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -92,7 +97,12 @@ where
     }
 
     fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -187,7 +197,12 @@ where
     }
 
     fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -200,7 +215,12 @@ where
     }
 
     fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -256,7 +276,12 @@ where
     }
 
     fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -269,7 +294,12 @@ where
     }
 
     fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
diff --git a/src/ord.rs b/src/ord.rs
index d475c2f..aa768cb 100644
--- a/src/ord.rs
+++ b/src/ord.rs
@@ -55,7 +55,12 @@ where
     }
 
     fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -71,7 +76,12 @@ where
     }
 
     fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -85,10 +95,12 @@ where
         let palette = crate::Palette::current();
         write!(
             f,
-            "{} {} {:?}",
+            "{} {} {}",
             palette.var.paint("var"),
             palette.description.paint(self.op),
-            self.constant
+            palette
+                .expected
+                .paint(utils::DebugAdapter::new(&self.constant)),
         )
     }
 }
@@ -188,7 +200,12 @@ where
     }
 
     fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -206,7 +223,12 @@ where
     }
 
     fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                utils::DebugAdapter::new(variable).to_string(),
+            ))
+        })
     }
 }
 
@@ -220,10 +242,12 @@ where
         let palette = crate::Palette::current();
         write!(
             f,
-            "{} {} {:?}",
+            "{} {} {}",
             palette.var.paint("var"),
             palette.description.paint(self.op),
-            self.constant
+            palette
+                .expected
+                .paint(utils::DebugAdapter::new(&self.constant)),
         )
     }
 }
diff --git a/src/path/existence.rs b/src/path/existence.rs
index 5580abb..c16d362 100644
--- a/src/path/existence.rs
+++ b/src/path/existence.rs
@@ -31,7 +31,12 @@ impl Predicate<path::Path> for ExistencePredicate {
         expected: bool,
         variable: &path::Path,
     ) -> Option<reflection::Case<'a>> {
-        utils::default_find_case(self, expected, variable)
+        utils::default_find_case(self, expected, variable).map(|case| {
+            case.add_product(reflection::Product::new(
+                "var",
+                variable.display().to_string(),
+            ))
+        })
     }
 }
 
diff --git a/src/path/fc.rs b/src/path/fc.rs
index 952d2ec..f16c156 100644
--- a/src/path/fc.rs
+++ b/src/path/fc.rs
@@ -75,13 +75,19 @@ where
     ) -> Option<reflection::Case<'a>> {
         let buffer = read_file(variable);
         match (expected, buffer) {
-            (_, Ok(buffer)) => self
-                .p
-                .find_case(expected, &buffer)
-                .map(|child| reflection::Case::new(Some(self), expected).add_child(child)),
+            (_, Ok(buffer)) => self.p.find_case(expected, &buffer).map(|case| {
+                case.add_product(reflection::Product::new(
+                    "var",
+                    variable.display().to_string(),
+                ))
+            }),
             (true, Err(_)) => None,
             (false, Err(err)) => Some(
                 reflection::Case::new(Some(self), false)
+                    .add_product(reflection::Product::new(
+                        "var",
+                        variable.display().to_string(),
+                    ))
                     .add_product(reflection::Product::new("error", err)),
             ),
         }
diff --git a/src/str/basics.rs b/src/str/basics.rs
index 4d3171b..f7c19a2 100644
--- a/src/str/basics.rs
+++ b/src/str/basics.rs
@@ -25,6 +25,7 @@ impl Predicate<str> for IsEmptyPredicate {
 
     fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
         utils::default_find_case(self, expected, variable)
+            .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
     }
 }
 
@@ -72,6 +73,7 @@ impl Predicate<str> for StartsWithPredicate {
 
     fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
         utils::default_find_case(self, expected, variable)
+            .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
     }
 }
 
@@ -125,6 +127,7 @@ impl Predicate<str> for EndsWithPredicate {
 
     fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
         utils::default_find_case(self, expected, variable)
+            .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
     }
 }
 
@@ -198,6 +201,7 @@ impl Predicate<str> for ContainsPredicate {
 
     fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
         utils::default_find_case(self, expected, variable)
+            .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
     }
 }
 
@@ -236,6 +240,7 @@ impl Predicate<str> for MatchesPredicate {
         if result == expected {
             Some(
                 reflection::Case::new(Some(self), result)
+                    .add_product(reflection::Product::new("var", variable.to_owned()))
                     .add_product(reflection::Product::new("actual count", actual_count)),
             )
         } else {
diff --git a/src/str/regex.rs b/src/str/regex.rs
index 5657b8f..5341b30 100644
--- a/src/str/regex.rs
+++ b/src/str/regex.rs
@@ -47,6 +47,7 @@ impl Predicate<str> for RegexPredicate {
 
     fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
         utils::default_find_case(self, expected, variable)
+            .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
     }
 }
 
@@ -85,6 +86,7 @@ impl Predicate<str> for RegexMatchesPredicate {
         if result == expected {
             Some(
                 reflection::Case::new(Some(self), result)
+                    .add_product(reflection::Product::new("var", variable.to_owned()))
                     .add_product(reflection::Product::new("actual count", actual_count)),
             )
         } else {