diff --git a/Changes b/Changes
index 58c07fc5d..01781f87b 100644
--- a/Changes
+++ b/Changes
@@ -41,6 +41,7 @@ Verilator 5.039 devel
 * Support disabling a fork from within that fork (#6314). [Ryszard Rozak, Antmicro Ltd.]
 * Change control file `public_flat_*` and other signal attributes to support __ in names (#6140).
 * Change runtime to exit() instead of abort(), unless under +verilated+debug.
+* Change `$display("%p")` to remove space after `}`.
 * Improve `--skip-identical` to skip on identical input file contents (#6109).
 * Optimize to return memory when using -build (#6192) (#6226). [Michael B. Taylor]
 * Optimize 2 ** X to 1 << X if base is signed (#6203). [Max Wipfli]
diff --git a/include/verilated_types.h b/include/verilated_types.h
index b4e51caa8..0fa30d2ca 100644
--- a/include/verilated_types.h
+++ b/include/verilated_types.h
@@ -917,7 +917,7 @@ public:
             out += comma + VL_TO_STRING(i);
             comma = ", ";
         }
-        return out + "} ";
+        return out + "}";
     }
 };
 
@@ -1256,7 +1256,7 @@ public:
             comma = ", ";
         }
         // Default not printed - maybe random init data
-        return out + "} ";
+        return out + "}";
     }
 };
 
@@ -1629,7 +1629,7 @@ public:
             out += comma + VL_TO_STRING(m_storage[i]);
             comma = ", ";
         }
-        return out + "} ";
+        return out + "}";
     }
 
 private:
diff --git a/test_regress/t/t_array_method.v b/test_regress/t/t_array_method.v
index 0ad0d177f..4f5021dad 100644
--- a/test_regress/t/t_array_method.v
+++ b/test_regress/t/t_array_method.v
@@ -19,41 +19,41 @@ module t;
     string v;
 
     q = '{1, 2, 2, 4, 3};
-    `checkp(q, "'{'h1, 'h2, 'h2, 'h4, 'h3} ");
+    `checkp(q, "'{'h1, 'h2, 'h2, 'h4, 'h3}");
 
     // NOT tested: with ... selectors
 
     q.sort;
-    `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+    `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
     q.sort with (item == 2);
-    `checkp(q, "'{'h1, 'h3, 'h4, 'h2, 'h2} ");
+    `checkp(q, "'{'h1, 'h3, 'h4, 'h2, 'h2}");
     q.sort(x) with (x == 3);
-    `checkp(q, "'{'h1, 'h4, 'h2, 'h2, 'h3} ");
+    `checkp(q, "'{'h1, 'h4, 'h2, 'h2, 'h3}");
 
     q.rsort;
-    `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1} ");
+    `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1}");
     q.rsort with (item == 2);
-    `checkp(q, "'{'h2, 'h2, 'h4, 'h3, 'h1} ");
+    `checkp(q, "'{'h2, 'h2, 'h4, 'h3, 'h1}");
 
     qv = q.unique;
-    `checkp(qv, "'{'h2, 'h4, 'h3, 'h1} ");
+    `checkp(qv, "'{'h2, 'h4, 'h3, 'h1}");
     qi = q.unique_index;
     qi.sort;
-    `checkp(qi, "'{'h0, 'h2, 'h3, 'h4} ");
+    `checkp(qi, "'{'h0, 'h2, 'h3, 'h4}");
     q.reverse;
-    `checkp(q, "'{'h1, 'h3, 'h4, 'h2, 'h2} ");
+    `checkp(q, "'{'h1, 'h3, 'h4, 'h2, 'h2}");
     q.shuffle();
     q.sort;
-    `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+    `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
 
     // These require an with clause or are illegal
     // TODO add a lint check that with clause is provided
     qv = q.find with (item == 2);
-    `checkp(qv, "'{'h2, 'h2} ");
+    `checkp(qv, "'{'h2, 'h2}");
     qv = q.find_first with (item == 2);
-    `checkp(qv, "'{'h2} ");
+    `checkp(qv, "'{'h2}");
     qv = q.find_last with (item == 2);
-    `checkp(qv, "'{'h2} ");
+    `checkp(qv, "'{'h2}");
 
     qv = q.find with (item == 20);
     `checkp(qv, "'{}");
@@ -64,11 +64,11 @@ module t;
 
     qi = q.find_index with (item == 2);
     qi.sort;
-    `checkp(qi, "'{'h1, 'h2} ");
+    `checkp(qi, "'{'h1, 'h2}");
     qi = q.find_first_index with (item == 2);
-    `checkp(qi, "'{'h1} ");
+    `checkp(qi, "'{'h1}");
     qi = q.find_last_index with (item == 2);
-    `checkp(qi, "'{'h2} ");
+    `checkp(qi, "'{'h2}");
 
     qi = q.find_index with (item == 20);
     qi.sort;
@@ -79,9 +79,9 @@ module t;
     `checkp(qi, "'{}");
 
     qv = q.min;
-    `checkp(qv, "'{'h1} ");
+    `checkp(qv, "'{'h1}");
     qv = q.max;
-    `checkp(qv, "'{'h4} ");
+    `checkp(qv, "'{'h4}");
 
     // Reduction methods
 
@@ -99,7 +99,7 @@ module t;
     `checkh(i, 32'ha);
 
     q = '{1, 2, 2, 4, 3};
-    // `checkp(q, "'{1, 2, 2, 4, 3} ");
+    // `checkp(q, "'{1, 2, 2, 4, 3}");
 
     i = q.sum with (item + 1);
     `checkh(i, 32'h11);
diff --git a/test_regress/t/t_assoc.v b/test_regress/t/t_assoc.v
index 24760e758..c8cae1b37 100644
--- a/test_regress/t/t_assoc.v
+++ b/test_regress/t/t_assoc.v
@@ -46,7 +46,7 @@ module t (/*AUTOARG*/
          i = a.last(k); `checkh(i, 1); `checks(k, 4'd3);
          i = a.prev(k); `checkh(i, 1); `checks(k, 4'd2);
          i = a.prev(k); `checkh(i, 0);
-         `checkp(a, "'{'h2:\"bared\", 'h3:\"fooed\"} ");
+         `checkp(a, "'{'h2:\"bared\", 'h3:\"fooed\"}");
 
          a.first(k); `checks(k, 4'd2);
          a.next(k); `checks(k, 4'd3);
@@ -82,7 +82,7 @@ module t (/*AUTOARG*/
          i = a.prev(k); `checkh(i, 1); `checks(k, "bar");
          i = a.prev(k); `checkh(i, 0);
          `checkp(a["foo"], "\"fooed\"");
-         `checkp(a, "'{\"bar\":\"bared\", \"foo\":\"fooed\"} ");
+         `checkp(a, "'{\"bar\":\"bared\", \"foo\":\"fooed\"}");
 
          a.delete("bar");
          i = a.size(); `checkh(i, 1);
diff --git a/test_regress/t/t_assoc_method.v b/test_regress/t/t_assoc_method.v
index 5ae0e73fa..e78370d51 100644
--- a/test_regress/t/t_assoc_method.v
+++ b/test_regress/t/t_assoc_method.v
@@ -27,7 +27,7 @@ module t (/*AUTOARG*/);
       bit b;
 
       q = '{10:1, 11:2, 12:2, 13:4, 14:3};
-      `checkp(q, "'{'ha:'h1, 'hb:'h2, 'hc:'h2, 'hd:'h4, 'he:'h3} ");
+      `checkp(q, "'{'ha:'h1, 'hb:'h2, 'hc:'h2, 'hd:'h4, 'he:'h3}");
 
       // NOT tested: with ... selectors
 
@@ -38,11 +38,11 @@ module t (/*AUTOARG*/);
 
       `checkp(qe, "'{}");
       qv = q.unique;
-      `checkp(qv, "'{'h1, 'h2, 'h4, 'h3} ");
+      `checkp(qv, "'{'h1, 'h2, 'h4, 'h3}");
       qv = qe.unique;
       `checkp(qv, "'{}");
       qi = q.unique_index; qi.sort;
-      `checkp(qi, "'{'ha, 'hb, 'hd, 'he} ");
+      `checkp(qi, "'{'ha, 'hb, 'hd, 'he}");
       qi = qe.unique_index;
       `checkp(qi, "'{}");
 
@@ -54,16 +54,16 @@ module t (/*AUTOARG*/);
       `checkh(points_qv.size, 2);
       qi = points_q.unique_index(p) with (p.x + p.y);
       qi.sort;
-      `checkp(qi, "'{'h0, 'h1, 'h5} ");
+      `checkp(qi, "'{'h0, 'h1, 'h5}");
 
       // These require an with clause or are illegal
       // TODO add a lint check that with clause is provided
       qv = q.find with (item == 2);
-      `checkp(qv, "'{'h2, 'h2} ");
+      `checkp(qv, "'{'h2, 'h2}");
       qv = q.find_first with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
       qv = q.find_last with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
 
       qv = q.find with (item == 20);
       `checkp(qv, "'{}");
@@ -73,11 +73,11 @@ module t (/*AUTOARG*/);
       `checkp(qv, "'{}");
 
       qi = q.find_index with (item == 2); qi.sort;
-      `checkp(qi, "'{'hb, 'hc} ");
+      `checkp(qi, "'{'hb, 'hc}");
       qi = q.find_first_index with (item == 2);
-      `checkp(qi, "'{'hb} ");
+      `checkp(qi, "'{'hb}");
       qi = q.find_last_index with (item == 2);
-      `checkp(qi, "'{'hc} ");
+      `checkp(qi, "'{'hc}");
 
       qi = q.find_index with (item == 20); qi.sort;
       `checkp(qi, "'{}");
@@ -87,17 +87,17 @@ module t (/*AUTOARG*/);
       `checkp(qi, "'{}");
 
       qi = q.find_index with (item.index == 12);
-      `checkp(qi, "'{'hc} ");
+      `checkp(qi, "'{'hc}");
       qi = q.find with (item.index == 12);
-      `checkp(qi, "'{'h2} ");
+      `checkp(qi, "'{'h2}");
 
       qv = q.min;
-      `checkp(qv, "'{'h1} ");
+      `checkp(qv, "'{'h1}");
       points_qv = points_q.min(p) with (p.x + p.y);
       if (points_qv[0].x != 1 || points_qv[0].y != 2) $stop;
 
       qv = q.max;
-      `checkp(qv, "'{'h4} ");
+      `checkp(qv, "'{'h4}");
       points_qv = points_q.max(p) with (p.x + p.y);
       if (points_qv[0].x != 2 || points_qv[0].y != 4) $stop;
 
diff --git a/test_regress/t/t_assoc_wildcard_method.v b/test_regress/t/t_assoc_wildcard_method.v
index c8d51d6c6..29d374fee 100644
--- a/test_regress/t/t_assoc_wildcard_method.v
+++ b/test_regress/t/t_assoc_wildcard_method.v
@@ -26,7 +26,7 @@ module t (/*AUTOARG*/);
       string v;
 
       q = '{"a":1, "b":2, "c":2, "d":4, "e":3};
-      `checkp(q, "'{\"a\":'h1, \"b\":'h2, \"c\":'h2, \"d\":'h4, \"e\":'h3} ");
+      `checkp(q, "'{\"a\":'h1, \"b\":'h2, \"c\":'h2, \"d\":'h4, \"e\":'h3}");
 
       // NOT tested: with ... selectors
 
@@ -37,7 +37,7 @@ module t (/*AUTOARG*/);
 
       `checkp(qe, "'{}");
       qv = q.unique;
-      `checkp(qv, "'{'h1, 'h2, 'h4, 'h3} ");
+      `checkp(qv, "'{'h1, 'h2, 'h4, 'h3}");
       qv = qe.unique;
       `checkp(qv, "'{}");
 
@@ -45,11 +45,11 @@ module t (/*AUTOARG*/);
 
       // These require an with clause or are illegal
       qv = q.find with (item == 2);
-      `checkp(qv, "'{'h2, 'h2} ");
+      `checkp(qv, "'{'h2, 'h2}");
       qv = q.find_first with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
       qv = q.find_last with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
 
       qv = q.find with (item == 20);
       `checkp(qv, "'{}");
@@ -63,9 +63,9 @@ module t (/*AUTOARG*/);
       //q.find_last_index;  // Not legal on wildcard assoc - see t_assoc_wildcard_bad
 
       qv = q.min;
-      `checkp(qv, "'{'h1} ");
+      `checkp(qv, "'{'h1}");
       qv = q.max;
-      `checkp(qv, "'{'h4} ");
+      `checkp(qv, "'{'h4}");
 
       qv = qe.min;
       `checkp(qv, "'{}");
diff --git a/test_regress/t/t_class_format.out b/test_regress/t/t_class_format.out
index 4fef2ba25..219ddc86b 100644
--- a/test_regress/t/t_class_format.out
+++ b/test_regress/t/t_class_format.out
@@ -1,4 +1,4 @@
-''{b:'h1, i:'h2a, carray4:'{'h11, 'h22, 'h33, 'h44} , cwide:'{'h0, 'h0} , name:"object_name", r:2.2}'
-''{b:'h1, i:'h2a, carray4:'{'h911, 'h922, 'h933, 'h944} , cwide:'{'h0, 'h0} , name:"object_name", r:2.2}'
+''{b:'h1, i:'h2a, carray4:'{'h11, 'h22, 'h33, 'h44}, cwide:'{'h0, 'h0}, name:"object_name", r:2.2}'
+''{b:'h1, i:'h2a, carray4:'{'h911, 'h922, 'h933, 'h944}, cwide:'{'h0, 'h0}, name:"object_name", r:2.2}'
 DEBUG: object_name (@0) message
 *-* All Finished *-*
diff --git a/test_regress/t/t_dynarray.v b/test_regress/t/t_dynarray.v
index 01b53d37d..2323ade0a 100644
--- a/test_regress/t/t_dynarray.v
+++ b/test_regress/t/t_dynarray.v
@@ -57,7 +57,7 @@ module t (/*AUTOARG*/
          `checkh(a[0], 10);
          `checkh(a[1], 11);
          `checkh(a[2], 12);
-         `checkp(a, "'{'ha, 'hb, 'hc} ");
+         `checkp(a, "'{'ha, 'hb, 'hc}");
          a.delete;
          `checkh(a.size, 0);
 
diff --git a/test_regress/t/t_dynarray_concat.v b/test_regress/t/t_dynarray_concat.v
index ad41498ca..fd21b3780 100644
--- a/test_regress/t/t_dynarray_concat.v
+++ b/test_regress/t/t_dynarray_concat.v
@@ -37,26 +37,26 @@ module t(/*AUTOARG*/);
 
    initial begin
       `checkp(da, "'{}");
-      `checkp(da2, "'{'{'h1, 'h2} } ");
+      `checkp(da2, "'{'{'h1, 'h2}}");
 
       `checkp(dd, "'{}");
-      `checkp(dd1, "'{'{'h1} } ");
-      `checkp(dd2, "'{'{'h1, 'h2} } ");
+      `checkp(dd1, "'{'{'h1}}");
+      `checkp(dd2, "'{'{'h1, 'h2}}");
 
       `checkp(dq, "'{}");
-      `checkp(dq1, "'{'{'h1} } ");
-      `checkp(dq2, "'{'{'h1, 'h2} } ");
+      `checkp(dq1, "'{'{'h1}}");
+      `checkp(dq2, "'{'{'h1, 'h2}}");
 
       `checkp(qa, "'{}");
-      `checkp(qa2, "'{'{'h1, 'h2} } ");
+      `checkp(qa2, "'{'{'h1, 'h2}}");
 
       `checkp(qd, "'{}");
-      `checkp(qd1, "'{'{'h1} } ");
-      `checkp(qd2, "'{'{'h1, 'h2} } ");
+      `checkp(qd1, "'{'{'h1}}");
+      `checkp(qd2, "'{'{'h1, 'h2}}");
 
       `checkp(qq, "'{}");
-      `checkp(qq1, "'{'{'h1} } ");
-      `checkp(qq2, "'{'{'h1, 'h2} } ");
+      `checkp(qq1, "'{'{'h1}}");
+      `checkp(qq2, "'{'{'h1, 'h2}}");
 
       $write("*-* All Finished *-*\n");
       $finish;
diff --git a/test_regress/t/t_dynarray_method.v b/test_regress/t/t_dynarray_method.v
index 847cf1a69..97c25ca63 100644
--- a/test_regress/t/t_dynarray_method.v
+++ b/test_regress/t/t_dynarray_method.v
@@ -22,53 +22,53 @@ module t (/*AUTOARG*/);
       int i;
 
       d = '{1, 2, 2, 4, 3};
-      `checkp(d, "'{'h1, 'h2, 'h2, 'h4, 'h3} ");
+      `checkp(d, "'{'h1, 'h2, 'h2, 'h4, 'h3}");
       d = {1, 2, 2, 4, 3};
-      `checkp(d, "'{'h1, 'h2, 'h2, 'h4, 'h3} ");
+      `checkp(d, "'{'h1, 'h2, 'h2, 'h4, 'h3}");
 
       // sort/rsort with clause is the field to use for the sorting
       d.sort;
-      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
       d.sort with (10 - item);
-      `checkp(d, "'{'h4, 'h3, 'h2, 'h2, 'h1} ");
+      `checkp(d, "'{'h4, 'h3, 'h2, 'h2, 'h1}");
       d.sort(x) with (10 - x);
-      `checkp(d, "'{'h4, 'h3, 'h2, 'h2, 'h1} ");
+      `checkp(d, "'{'h4, 'h3, 'h2, 'h2, 'h1}");
       de.sort(x) with (10 - x);
       `checkp(de, "'{}");
       d.rsort;
-      `checkp(d, "'{'h4, 'h3, 'h2, 'h2, 'h1} ");
+      `checkp(d, "'{'h4, 'h3, 'h2, 'h2, 'h1}");
       d.rsort with (10 - item);
-      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
       de.rsort(x) with (10 - x);
-      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
 
       d = '{2, 2, 4, 1, 3};
       qv = d.unique;
-      `checkp(qv, "'{'h2, 'h4, 'h1, 'h3} ");
+      `checkp(qv, "'{'h2, 'h4, 'h1, 'h3}");
       qv = de.unique;
       `checkh(qv.size(), 0);
       qi = d.unique_index; qv.sort;
-      `checkp(qi, "'{'h0, 'h2, 'h3, 'h4} ");
+      `checkp(qi, "'{'h0, 'h2, 'h3, 'h4}");
       qi = de.unique_index;
       `checkh(qi.size(), 0);
 
       d.reverse;
-      `checkp(d, "'{'h3, 'h1, 'h4, 'h2, 'h2} ");
+      `checkp(d, "'{'h3, 'h1, 'h4, 'h2, 'h2}");
       de.reverse;
       `checkh(de.size(), 0);
       d.shuffle(); d.sort;
-      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(d, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
       de.shuffle();
       `checkh(de.size(), 0);
 
       // These require an with clause or are illegal
       // TODO add a lint check that with clause is provided
       qv = d.find with (item == 2);
-      `checkp(qv, "'{'h2, 'h2} ");
+      `checkp(qv, "'{'h2, 'h2}");
       qv = d.find_first with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
       qv = d.find_last with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
 
       qv = d.find with (item == 20);
       `checkh(qv.size, 0);
@@ -81,15 +81,15 @@ module t (/*AUTOARG*/);
       qvunused = d.find with (item == 20);
 
       qi = d.find_index with (item == 2);
-      qi.sort; `checkp(qi, "'{'h1, 'h2} ");
+      qi.sort; `checkp(qi, "'{'h1, 'h2}");
       qi = d.find_first_index with (item == 2);
-      `checkp(qi, "'{'h1} ");
+      `checkp(qi, "'{'h1}");
       qi = d.find_last_index with (item == 2);
-      `checkp(qi, "'{'h2} ");
+      `checkp(qi, "'{'h2}");
 
       i = 2;
       qi = d.find_index with (item == i);
-      qi.sort; `checkp(qi, "'{'h1, 'h2} ");
+      qi.sort; `checkp(qi, "'{'h1, 'h2}");
 
       qi = d.find_index with (item == 20); qi.sort;
       `checkh(qi.size, 0);
@@ -99,12 +99,12 @@ module t (/*AUTOARG*/);
       `checkh(qi.size, 0);
 
       qi = d.find_index with (item.index == 2);
-      `checkp(qi, "'{'h2} ");
+      `checkp(qi, "'{'h2}");
 
       qv = d.min;
-      `checkp(qv, "'{'h1} ");
+      `checkp(qv, "'{'h1}");
       qv = d.max;
-      `checkp(qv, "'{'h4} ");
+      `checkp(qv, "'{'h4}");
       qv = de.min;
       `checkp(qv, "'{}");
       qv = de.max;
diff --git a/test_regress/t/t_interface_virtual.out b/test_regress/t/t_interface_virtual.out
index 315bffb65..121116c8c 100644
--- a/test_regress/t/t_interface_virtual.out
+++ b/test_regress/t/t_interface_virtual.out
@@ -7,5 +7,5 @@ vb.addr=bb vb.data=22 ib.addr=bb ib.data=22
 ca.fa.addr=a0 ca.fa.data=11 ca.fa.addr=b0 ca.fb.data=22
 cb.fa.addr=b0 cb.fa.data=22 cb.fa.addr=a0 cb.fb.data=11
 gen.x[0].addr=a0 gen.x[1].addr=b0
-gen='{x:'{top.t.ia, top.t.ib, null, null} }
+gen='{x:'{top.t.ia, top.t.ib, null, null}}
 *-* All Finished *-*
diff --git a/test_regress/t/t_queue.v b/test_regress/t/t_queue.v
index 20660e2c4..140561649 100644
--- a/test_regress/t/t_queue.v
+++ b/test_regress/t/t_queue.v
@@ -149,7 +149,7 @@ module t (/*AUTOARG*/
          v = q[4]; `checks(v, "");
          //Unsup: `checkh(q[$], "b2");
 
-         `checkp(q, "'{\"f2\", \"f1\", \"b1\", \"b2\"} ");
+         `checkp(q, "'{\"f2\", \"f1\", \"b1\", \"b2\"}");
          `checkp(p, "'{}");
 
          //Unsup: q.delete(1);
diff --git a/test_regress/t/t_queue_method.v b/test_regress/t/t_queue_method.v
index d5d8dfe4a..40798c065 100644
--- a/test_regress/t/t_queue_method.v
+++ b/test_regress/t/t_queue_method.v
@@ -52,27 +52,27 @@ module t (/*AUTOARG*/);
       string_q.push_back("b");
 
       q = '{1, 2, 2, 4, 3};
-      `checkp(q, "'{'h1, 'h2, 'h2, 'h4, 'h3} ");
+      `checkp(q, "'{'h1, 'h2, 'h2, 'h4, 'h3}");
 
       // sort/rsort with clause is the field to use for the sorting
       q.sort;
-      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
       q.sort with (10 - item);
-      `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1} ");
+      `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1}");
       q.sort(x) with (10 - x);
-      `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1} ");
+      `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1}");
       qe.sort(x) with (10 - x);
       `checkp(qe, "'{}");
       q.rsort;
-      `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1} ");
+      `checkp(q, "'{'h4, 'h3, 'h2, 'h2, 'h1}");
       q.rsort with (10 - item);
-      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
       qe.rsort(x) with (10 - x);
-      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
 
       q = '{2, 2, 4, 1, 3};
       qv = q.unique;
-      `checkp(qv, "'{'h2, 'h4, 'h1, 'h3} ");
+      `checkp(qv, "'{'h2, 'h4, 'h1, 'h3}");
       qv = qe.unique;
       `checkh(qv.size(), 0);
       qv = q.unique(x) with (x % 2);
@@ -83,7 +83,7 @@ module t (/*AUTOARG*/);
       // According to IEEE 1800-2023 7.12.1, it is not specified which index of duplicated value should be returned
       `checkh(qi.size(), 4);
       qi.delete(1);
-      `checkp(qi, "'{'h0, 'h3, 'h4} ");
+      `checkp(qi, "'{'h0, 'h3, 'h4}");
       qi = qe.unique_index;
       `checkh(qi.size(), 0);
       qi = q.unique_index(x) with (x % 3); qv.sort;
@@ -94,31 +94,31 @@ module t (/*AUTOARG*/);
       `checkh(cls_qv.size(), 1);
       qi = cls_q.unique_index with (item.x % 2);
       qi.sort;
-      `checkp(qi, "'{'h0, 'h1} ");
+      `checkp(qi, "'{'h0, 'h1}");
 
       q.reverse;
-      `checkp(q, "'{'h3, 'h1, 'h4, 'h2, 'h2} ");
+      `checkp(q, "'{'h3, 'h1, 'h4, 'h2, 'h2}");
       qe.reverse;
       `checkh(qe.size(), 0);
       q.shuffle(); q.sort;
-      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4} ");
+      `checkp(q, "'{'h1, 'h2, 'h2, 'h3, 'h4}");
       qe.shuffle();
       `checkh(qe.size(), 0);
 
       // These require an with clause or are illegal
       // TODO add a lint check that with clause is provided
       qv = q.find with (item == 2);
-      `checkp(qv, "'{'h2, 'h2} ");
+      `checkp(qv, "'{'h2, 'h2}");
       qv = q.find with (item[0] == 1);
-      `checkp(qv, "'{'h1, 'h3} ");
+      `checkp(qv, "'{'h1, 'h3}");
       qv = q.find_first with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
       points_qv = points_q.find_first with (item.z == 5);
       `checkh(points_qv[0].p.y, 3);
       points_qv = points_q.find_first with (item.p.x == 1);
       `checkh(points_qv[0].p.y, 2);
       qv = q.find_last with (item == 2);
-      `checkp(qv, "'{'h2} ");
+      `checkp(qv, "'{'h2}");
       string_qv = string_q.find_last(s) with (s.tolower() == "a");
       `checks(string_qv[0], "A");
 
@@ -133,15 +133,15 @@ module t (/*AUTOARG*/);
       qvunused = q.find with (item == 20);
 
       qi = q.find_index with (item == 2);
-      qi.sort; `checkp(qi, "'{'h1, 'h2} ");
+      qi.sort; `checkp(qi, "'{'h1, 'h2}");
       qi = q.find_first_index with (item == 2);
-      `checkp(qi, "'{'h1} ");
+      `checkp(qi, "'{'h1}");
       qi = q.find_last_index with (item == 2);
-      `checkp(qi, "'{'h2} ");
+      `checkp(qi, "'{'h2}");
 
       i = 2;
       qi = q.find_index with (item == i);
-      qi.sort; `checkp(qi, "'{'h1, 'h2} ");
+      qi.sort; `checkp(qi, "'{'h1, 'h2}");
 
       qi = q.find_index with (item == 20); qi.sort;
       `checkh(qi.size, 0);
@@ -151,18 +151,18 @@ module t (/*AUTOARG*/);
       `checkh(qi.size, 0);
 
       qi = q.find_index with (item.index == 2);
-      `checkp(qi, "'{'h2} ");
+      `checkp(qi, "'{'h2}");
       qi = q.find_index with (item.index == item);
-      `checkp(qi, "'{'h2, 'h3, 'h4} ");
+      `checkp(qi, "'{'h2, 'h3, 'h4}");
 
       qv = q.min;
-      `checkp(qv, "'{'h1} ");
+      `checkp(qv, "'{'h1}");
       qv = q.min(x) with (x + 1);
-      `checkp(qv, "'{'h1} ");
+      `checkp(qv, "'{'h1}");
       qv = q.max;
-      `checkp(qv, "'{'h4} ");
+      `checkp(qv, "'{'h4}");
       qv = q.max(x) with ((x % 4) + 100);
-      `checkp(qv, "'{'h3} ");
+      `checkp(qv, "'{'h3}");
       qv = qe.min;
       `checkp(qv, "'{}");
       qv = qe.max;
diff --git a/test_regress/t/t_queue_slice.v b/test_regress/t/t_queue_slice.v
index d7eec445a..bc622669e 100644
--- a/test_regress/t/t_queue_slice.v
+++ b/test_regress/t/t_queue_slice.v
@@ -20,46 +20,46 @@ module t (/*AUTOARG*/);
 
       q.push_front("non-empty");
       i = q.size(); `checkh(i, 1);
-      `checkp(q, "'{\"non-empty\"} ");
+      `checkp(q, "'{\"non-empty\"}");
 
       q = '{};
       i = q.size(); `checkh(i, 0);
 
       q = '{"q"};
-      `checkp(q, "'{\"q\"} ");
+      `checkp(q, "'{\"q\"}");
 
       q = {};
       i = q.size(); `checkh(i, 0);
 
       q = '{"q", "b", "c", "d", "e", "f"};
       if (q[0] !== "q") $stop;
-      `checkp(q, "'{\"q\", \"b\", \"c\", \"d\", \"e\", \"f\"} ");
+      `checkp(q, "'{\"q\", \"b\", \"c\", \"d\", \"e\", \"f\"}");
 
       q = {"q", "b", "c", "d", "e", "f"};
-      `checkp(q, "'{\"q\", \"b\", \"c\", \"d\", \"e\", \"f\"} ");
+      `checkp(q, "'{\"q\", \"b\", \"c\", \"d\", \"e\", \"f\"}");
 
       q.delete(1);
       v = q[1]; `checks(v, "c");
-      `checkp(q, "'{\"q\", \"c\", \"d\", \"e\", \"f\"} ");
+      `checkp(q, "'{\"q\", \"c\", \"d\", \"e\", \"f\"}");
 
       q.insert(0, "ins0");
       q.insert(2, "ins2");
       v = q[0]; `checks(v, "ins0");
       v = q[2]; `checks(v, "ins2");
-      `checkp(q, "'{\"ins0\", \"q\", \"ins2\", \"c\", \"d\", \"e\", \"f\"} ");
+      `checkp(q, "'{\"ins0\", \"q\", \"ins2\", \"c\", \"d\", \"e\", \"f\"}");
 
       // Slicing
       q = '{"q", "b", "c", "d", "e", "f"};
       q = q[-1:0];
-      `checkp(q, "'{\"q\"} ");
+      `checkp(q, "'{\"q\"}");
       q = '{"q", "b", "c", "d", "e", "f"};
       q = q[2:3];
-      `checkp(q, "'{\"c\", \"d\"} ");
+      `checkp(q, "'{\"c\", \"d\"}");
       q = '{"q", "b", "c", "d", "e", "f"};
       q = q[3:$];
-      `checkp(q, "'{\"d\", \"e\", \"f\"} ");
+      `checkp(q, "'{\"d\", \"e\", \"f\"}");
       q = q[$:$];
-      `checkp(q, "'{\"f\"} ");
+      `checkp(q, "'{\"f\"}");
 
       // Similar using implied notation
       q = '{"f"};
@@ -67,14 +67,14 @@ module t (/*AUTOARG*/);
       q = {q, "f2"};  // push_front
       q = {"b1", q};  // push_back
       q = {"b2", q};  // push_back
-      `checkp(q, "'{\"b2\", \"b1\", \"f\", \"f1\", \"f2\"} ");
+      `checkp(q, "'{\"b2\", \"b1\", \"f\", \"f1\", \"f2\"}");
 
       q = {q[0], q[2:$]};  // delete element 1
-      `checkp(q, "'{\"b2\", \"f\", \"f1\", \"f2\"} ");
+      `checkp(q, "'{\"b2\", \"f\", \"f1\", \"f2\"}");
 
       q = {"a", "b"};
       q = {q, q};
-      `checkp(q, "'{\"a\", \"b\", \"a\", \"b\"} ");
+      `checkp(q, "'{\"a\", \"b\", \"a\", \"b\"}");
 
       begin
          string ai[$] = '{ "Foo", "Bar" };
diff --git a/test_regress/t/t_stream_bitqueue.v b/test_regress/t/t_stream_bitqueue.v
index c44bdf749..a9fc0ed91 100644
--- a/test_regress/t/t_stream_bitqueue.v
+++ b/test_regress/t/t_stream_bitqueue.v
@@ -263,16 +263,16 @@ module t (  /*AUTOARG*/
       `checkh(bytq_init[0], 8'h84);
       `checkh(bytq_init[1], 8'haa);
       s = $sformatf("bytq_init=%p", bytq_init);
-      `checks(s, "bytq_init='{'h84, 'haa} ");
+      `checks(s, "bytq_init='{'h84, 'haa}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bitq=%p", bitq);
       `checks(s,
-              "bitq='{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1} ");
+              "bitq='{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1}");
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa} ");
+      `checks(s, "bytq='{'h84, 'haa}");
 
       /*
         Generalized block-reversal semantics for the outer left-stream when blockSize > 1.
@@ -298,12 +298,12 @@ module t (  /*AUTOARG*/
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bitq=%p", bitq);
       `checks(s,
-              "bitq='{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h1} ");
+              "bitq='{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h1}");
       `checkh(bytq[0], 8'h84);
       `checkh(bytq[1], 8'haa);
       `checkh(bytq[2], 8'h80);
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'h80} ");
+      `checks(s, "bytq='{'h84, 'haa, 'h80}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -312,9 +312,9 @@ module t (  /*AUTOARG*/
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bitq=%p", bitq);
       `checks(s,
-              "bitq='{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h1, 'h1} ");
+              "bitq='{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h1, 'h1}");
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'hc0} ");
+      `checks(s, "bytq='{'h84, 'haa, 'hc0}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -323,7 +323,7 @@ module t (  /*AUTOARG*/
       bitq.push_back(1'b1);
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'he0} ");
+      `checks(s, "bytq='{'h84, 'haa, 'he0}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -333,7 +333,7 @@ module t (  /*AUTOARG*/
       bitq.push_back(1'b0);
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'h70} ");
+      `checks(s, "bytq='{'h84, 'haa, 'h70}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -344,7 +344,7 @@ module t (  /*AUTOARG*/
       bitq.push_back(1'b1);
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'hb8} ");
+      `checks(s, "bytq='{'h84, 'haa, 'hb8}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -356,7 +356,7 @@ module t (  /*AUTOARG*/
       bitq.push_back(1'b0);
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'h5c} ");
+      `checks(s, "bytq='{'h84, 'haa, 'h5c}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -369,7 +369,7 @@ module t (  /*AUTOARG*/
       bitq.push_back(1'b0);
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'h2e} ");
+      `checks(s, "bytq='{'h84, 'haa, 'h2e}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -383,7 +383,7 @@ module t (  /*AUTOARG*/
       bitq.push_back(1'b1);
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'h97} ");
+      `checks(s, "bytq='{'h84, 'haa, 'h97}");
 
       bytq = bytq_init;
       bitq = {<<8{bit_q_t'({<<{bytq}})}};
@@ -398,7 +398,7 @@ module t (  /*AUTOARG*/
       bitq.push_back(1'b1);
       bytq = {<<8{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h84, 'haa, 'h97, 'h80} ");
+      `checks(s, "bytq='{'h84, 'haa, 'h97, 'h80}");
     end
 
     // Test StreamR (>>) operations - fairly simple since this should maintain left-to-right order.
@@ -409,13 +409,13 @@ module t (  /*AUTOARG*/
       bitq = {1'b1, 1'b0, 1'b1, 1'b0, 1'b1, 1'b0, 1'b1, 1'b0};
       bitq = {>>4{bit_q_t'({<<{bitq}})}};
       s = $sformatf("bitq=%p", bitq);
-      `checks(s, "bitq='{'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1} ");
+      `checks(s, "bitq='{'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1}");
 
       bytq = {8'h84, 8'haa};
       bitq = {>>{bit_q_t'({<<{bytq}})}};
       s = $sformatf("bitq=%p", bitq);
       `checks(s,
-              "bitq='{'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1} ");
+              "bitq='{'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1}");
 
       bitq = {
         1'b1,
@@ -437,23 +437,23 @@ module t (  /*AUTOARG*/
       };
       bytq = {>>2{byte_q_t'({<<{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h43, 'h55} ");
+      `checks(s, "bytq='{'h43, 'h55}");
 
       bytq = {8'h12, 8'h34, 8'h56};
       bytq = {>>{byte_q_t'({<<{bytq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h6a, 'h2c, 'h48} ");
+      `checks(s, "bytq='{'h6a, 'h2c, 'h48}");
 
       bitq = {1'b1, 1'b0, 1'b1, 1'b0, 1'b1, 1'b0, 1'b1, 1'b0};
       bitq = {>>6{bit_q_t'({>>{bitq}})}};
       s = $sformatf("bitq=%p", bitq);
-      `checks(s, "bitq='{'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0} ");
+      `checks(s, "bitq='{'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0}");
 
       bytq = {8'h84, 8'haa};
       bitq = {>>{bit_q_t'({>>{bytq}})}};
       s = $sformatf("bitq=%p", bitq);
       `checks(s,
-              "bitq='{'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0} ");
+              "bitq='{'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0}");
 
       bitq = {
         1'b1,
@@ -475,12 +475,12 @@ module t (  /*AUTOARG*/
       };
       bytq = {>>8{byte_q_t'({>>{bitq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'haa, 'hc2} ");
+      `checks(s, "bytq='{'haa, 'hc2}");
 
       bytq = {8'h12, 8'h34, 8'h56};
       bytq = {>>{byte_q_t'({>>{bytq}})}};
       s = $sformatf("bytq=%p", bytq);
-      `checks(s, "bytq='{'h12, 'h34, 'h56} ");
+      `checks(s, "bytq='{'h12, 'h34, 'h56}");
     end
 
     $write("*-* All Finished *-*\n");
diff --git a/test_regress/t/t_stream_crc_example.v b/test_regress/t/t_stream_crc_example.v
index 7f09a08d4..6b15bb2d1 100644
--- a/test_regress/t/t_stream_crc_example.v
+++ b/test_regress/t/t_stream_crc_example.v
@@ -53,14 +53,14 @@ module t (  /*AUTOARG*/
     po = {<<8{bit_q_t'({<<{bits}})}};
 
     s  = $sformatf("p=%p", p);
-    `checks(s, "p='{'h84, 'haa} ");
+    `checks(s, "p='{'h84, 'haa}");
 
     s = $sformatf("bits=%p", bits);
     `checks(s,
-            "bits='{'h0, 'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1} ");
+            "bits='{'h0, 'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1, 'h0, 'h1}");
 
     s = $sformatf("po=%p", po);
-    `checks(s, "po='{'h8, 'h55, 'h80} ");
+    `checks(s, "po='{'h8, 'h55, 'h80}");
   end
 
   always_ff @(posedge clk) begin
diff --git a/test_regress/t/t_stream_dynamic.v b/test_regress/t/t_stream_dynamic.v
index e9bdc97d9..ab6cfaa4d 100644
--- a/test_regress/t/t_stream_dynamic.v
+++ b/test_regress/t/t_stream_dynamic.v
@@ -36,7 +36,7 @@ module t (/*AUTOARG*/);
       arr160 = '{2{160'h0123456789abcdef0123456789abcdef01234567}};
 
       { >> bit {arr}} = bit6;
-      `checkp(arr, "'{'h1, 'h1, 'h1, 'h0, 'h0, 'h0} ");
+      `checkp(arr, "'{'h1, 'h1, 'h1, 'h0, 'h0, 'h0}");
       ans = { >> bit {arr} };
       `checkh(ans, bit6);
 
@@ -44,7 +44,7 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { << bit {arr}} = bit6;
-      `checkp(arr, "'{'h0, 'h0, 'h0, 'h1, 'h1, 'h1} ");
+      `checkp(arr, "'{'h0, 'h0, 'h0, 'h1, 'h1, 'h1}");
 
       ans = { << bit {arr} };
       `checkh(ans, bit6);
@@ -55,7 +55,7 @@ module t (/*AUTOARG*/);
 `ifdef VERILATOR
       // This set flags errors on other simulators
       { >> bit[1:0] {arr2}} = bit6;
-      `checkp(arr2, "'{'h3, 'h2, 'h0} ");
+      `checkp(arr2, "'{'h3, 'h2, 'h0}");
 
       ans = { >> bit[1:0] {arr2} };
       `checkh(ans, bit6);
@@ -64,7 +64,7 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { << bit[1:0] {arr2}} = bit6;
-      `checkp(arr2, "'{'h0, 'h2, 'h3} ");
+      `checkp(arr2, "'{'h0, 'h2, 'h3}");
 
       ans = { << bit[1:0] {arr2} };
       `checkh(ans, bit6);
@@ -73,7 +73,7 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { >> bit [5:0] {arr6} } = bit6;
-      `checkp(arr6, "'{'h38} ");
+      `checkp(arr6, "'{'h38}");
 
       ans = { >> bit[5:0] {arr6} };
       `checkh(ans, bit6);
@@ -82,7 +82,7 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { << bit [5:0] {arr6} } = bit6;
-      `checkp(arr6, "'{'h38} ");
+      `checkp(arr6, "'{'h38}");
 
       ans = { << bit[5:0] {arr6} };
       `checkh(ans, bit6);
diff --git a/test_regress/t/t_stream_unpack.v b/test_regress/t/t_stream_unpack.v
index ee6514123..571c96eda 100644
--- a/test_regress/t/t_stream_unpack.v
+++ b/test_regress/t/t_stream_unpack.v
@@ -43,10 +43,10 @@ module t (/*AUTOARG*/);
       logic [127:0] p[];
 
       { >> bit {arr}} = bit6;
-      `checkp(arr, "'{'h1, 'h1, 'h1, 'h0, 'h0, 'h0} ");
+      `checkp(arr, "'{'h1, 'h1, 'h1, 'h0, 'h0, 'h0}");
 
       arr = { >> bit {bit6}};
-      `checkp(arr, "'{'h1, 'h1, 'h1, 'h0, 'h0, 'h0} ");
+      `checkp(arr, "'{'h1, 'h1, 'h1, 'h0, 'h0, 'h0}");
 
       ans = { >> bit {arr} };
       `checkh(ans, bit6);
@@ -64,10 +64,10 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { << bit {arr}} = bit6;
-      `checkp(arr, "'{'h0, 'h0, 'h0, 'h1, 'h1, 'h1} ");
+      `checkp(arr, "'{'h0, 'h0, 'h0, 'h1, 'h1, 'h1}");
 
       arr = { << bit {bit6}};
-      `checkp(arr, "'{'h0, 'h0, 'h0, 'h1, 'h1, 'h1} ");
+      `checkp(arr, "'{'h0, 'h0, 'h0, 'h1, 'h1, 'h1}");
 
       ans = { << bit {arr} };
       `checkh(ans, bit6);
@@ -85,10 +85,10 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { >> bit[1:0] {arr2}} = bit6;
-      `checkp(arr2, "'{'h3, 'h2, 'h0} ");
+      `checkp(arr2, "'{'h3, 'h2, 'h0}");
 
       arr2 = { >> bit[1:0] {bit6}};
-      `checkp(arr2, "'{'h3, 'h2, 'h0} ");
+      `checkp(arr2, "'{'h3, 'h2, 'h0}");
 
       ans = { >> bit[1:0] {arr2} };
       `checkh(ans, bit6);
@@ -106,7 +106,7 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { << bit[1:0] {arr2}} = bit6;
-      `checkp(arr2, "'{'h0, 'h2, 'h3} ");
+      `checkp(arr2, "'{'h0, 'h2, 'h3}");
 
       ans = { << bit[1:0] {arr2} };
       `checkh(ans, bit6);
@@ -124,10 +124,10 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { >> bit [5:0] {arr6} } = bit6;
-      `checkp(arr6, "'{'h38} ");
+      `checkp(arr6, "'{'h38}");
 
       arr6 = { >> bit [5:0] {bit6}};
-      `checkp(arr6, "'{'h38} ");
+      `checkp(arr6, "'{'h38}");
 
       ans = { >> bit[5:0] {arr6} };
       `checkh(ans, bit6);
@@ -145,10 +145,10 @@ module t (/*AUTOARG*/);
       `checkh(ans_enum, bit6);
 
       { << bit [5:0] {arr6} } = bit6;
-      `checkp(arr6, "'{'h38} ");
+      `checkp(arr6, "'{'h38}");
 
       arr6 = { << bit [5:0] {bit6}};
-      `checkp(arr6, "'{'h38} ");
+      `checkp(arr6, "'{'h38}");
 
       ans = { << bit[5:0] {arr6} };
       `checkh(ans, bit6);
@@ -211,15 +211,15 @@ module t (/*AUTOARG*/);
       `checkh(d, 16'b0100110110001100);
 
       { >> {e, f}} = d;
-      `checkp(e, "'{'h4, 'hd} ");
-      `checkp(f, "'{'h1, 'h0, 'h0, 'h0, 'h1, 'h1, 'h0, 'h0} ");
+      `checkp(e, "'{'h4, 'hd}");
+      `checkp(f, "'{'h1, 'h0, 'h0, 'h0, 'h1, 'h1, 'h0, 'h0}");
 
       d = { << 4 {a, b, c}};
       `checkh(d, 16'b1100100011010100);
 
       { << 2 {e, f}} = d;
-      `checkp(e, "'{'h1, 'h7} ");
-      `checkp(f, "'{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h1, 'h1} ");
+      `checkp(e, "'{'h1, 'h7}");
+      `checkp(f, "'{'h0, 'h0, 'h1, 'h0, 'h0, 'h0, 'h1, 'h1}");
 
       g = { << 8 {16'hABCD}};
       `checkh(g, 16'hCDAB);
diff --git a/test_regress/t/t_struct_nest_uarray.v b/test_regress/t/t_struct_nest_uarray.v
index e3f8cda88..a1884398e 100644
--- a/test_regress/t/t_struct_nest_uarray.v
+++ b/test_regress/t/t_struct_nest_uarray.v
@@ -30,10 +30,10 @@ module t (/*AUTOARG*/);
 
    initial begin
       str.el[0].val.next = 6;
-      `checkp(str, "'{el:'{'{val:'{next:'h6}}} }");
+      `checkp(str, "'{el:'{'{val:'{next:'h6}}}}");
 
       pstr.el[0].val.next = 6;
-      `checkp(str, "'{el:'{'{val:'{next:'h6}}} }");
+      `checkp(str, "'{el:'{'{val:'{next:'h6}}}}");
 
       $write("*-* All Finished *-*\n");
       $finish;
diff --git a/test_regress/t/t_typename_min.v b/test_regress/t/t_typename_min.v
index 8d39ce5cc..49499924f 100644
--- a/test_regress/t/t_typename_min.v
+++ b/test_regress/t/t_typename_min.v
@@ -17,17 +17,17 @@ module t;
       s = $typename(array.min);
       `checks(s, "int$[$]");
       s = $sformatf("%p", array.min);
-      `checks(s, "'{'h1} ");
+      `checks(s, "'{'h1}");
 
       s = $typename(queue.min);
       `checks(s, "int$[$]");
       s = $sformatf("%p", queue.min);
-      `checks(s, "'{'h1} ");
+      `checks(s, "'{'h1}");
 
       s = $typename(assoc.min);
       `checks(s, "int$[$]");
       s = $sformatf("%p", assoc.min);
-      `checks(s, "'{'h1} ");
+      `checks(s, "'{'h1}");
 
       $write("*-* All Finished *-*\n");
       $finish;
diff --git a/test_regress/t/t_unpacked_array_p_fmt.out b/test_regress/t/t_unpacked_array_p_fmt.out
index 6872828ed..33a1ca411 100644
--- a/test_regress/t/t_unpacked_array_p_fmt.out
+++ b/test_regress/t/t_unpacked_array_p_fmt.out
@@ -1,3 +1,3 @@
-%p='{'h0, 'h1, 'h1, 'h0, 'h1, 'h0, 'h0, 'h1, 'h1, 'h0, 'h0, 'h1, 'h0, 'h1, 'h1, 'h0} 
-%p='{'{'h0, 'h1, 'h1, 'h0} , '{'h1, 'h0, 'h0, 'h1} , '{'h1, 'h0, 'h0, 'h1} , '{'h0, 'h1, 'h1, 'h0} } 
+%p='{'h0, 'h1, 'h1, 'h0, 'h1, 'h0, 'h0, 'h1, 'h1, 'h0, 'h0, 'h1, 'h0, 'h1, 'h1, 'h0}
+%p='{'{'h0, 'h1, 'h1, 'h0}, '{'h1, 'h0, 'h0, 'h1}, '{'h1, 'h0, 'h0, 'h1}, '{'h0, 'h1, 'h1, 'h0}}
 *-* All Finished *-*