Fix and document string.format (#436)

jcking · web-flow · commit 261e335b8219 · 2025-02-19T08:57:24.000-08:00
Signed-off-by: Justin King &lt;jcking@google.com&gt;
diff --git a/doc/extensions/strings.md b/doc/extensions/strings.md
@@ -0,0 +1,60 @@
+<!--
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Strings
+
+## string.format(list) -> string
+
+### Format
+
+`%[.precision]conversion`
+
+### Precision
+
+Optional. In the form of a period `.` followed by a required positive decimal digit sequence. The default precision is `6`. Not all conversions support precision.
+
+### Conversion
+
+|  Character | Precision | Description |
+| --- | --- | --- |
+| `s` | N | <table><tbody><tr><td><code>bool</code></td><td>The value is foramtted as <code>true</code> or <code>false</code>.</td></tr><tr><td><code>int</code></td><td>The value is formatted in base 10 with a preceding <code>-</code> if the value is negative. No insignificant <code>0</code>s must be included.</td></tr><tr><td><code>uint</code></td><td>The value is formatted in base 10. No insignificant <code>0</code>s must be included.</td></tr><tr><td><code>double</code></td><td>The value is formatted in base 10. No insignificant <code>0</code>s must be included. If there are no significant digits after the <code>.</code> then it must be excluded.</td></tr><tr><td><code>bytes</code></td><td>The value is formatted as if `string(value)` was performed and any invalid UTF-8 sequences are replaced with <code>\ufffd</code>. Multiple adjacent invalid UTF-8 sequences must be replaced with a single <code>\ufffd</code>.</td></tr><tr><td><code>string</code></td><td>The value is included as is.</td></tr><tr><td><code>duration</code></td><td>The value is formatted as decimal seconds as if the value was converted to <code>double</code> and then formatted as <code>%ds</code>.</td></tr><tr><td><code>timestamp</code></td><td>The value is formatted according to RFC 3339 and is always in UTC.</td></tr><tr><td><code>null_type</code></td><td>The value is formatted as <code>null</code>.</td></tr><tr><td><code>type</code></td><td>The value is formatted as a string.</td></tr><tr><td><code>list</code></td><td>The value is formatted as if each element was formatted as <code>"%s".format([element])</code>, joined together with <code>, </code> and enclosed with <code>[</code> and <code>]</code>.</td></tr><tr><td><code>map</code></td><td>The value is formatted as if each entry was formatted as <code>"%s: %s".format([key, value])</code>, sorted by the formatted keys in ascending order, joined together with <code>, </code>, and enclosed with <code>{</code> and <code>}</code>.</td></tr></tbody></table> |
+| `d` | N | <table><tbody><tr><td><code>int</code></td><td>The value is formatted in base 10 with a preceding <code>-</code> if the value is negative. No insignificant <code>0</code>s must be included.</td></tr><tr><td><code>uint</code></td><td>The value is formatted in base 10. No insignificant <code>0</code>s must be included.</td></tr><tr><td><code>double</code></td><td>The value is formatted in base 10. No insignificant <code>0</code>s must be included. If there are no significant digits after the <code>.</code> then it must be excluded.</td></tr></tbody></table> |
+| `f` | Y | `int` `uint` `double`: The value is converted to the style `[-]dddddd.dddddd` where there is at least one digit before the decimal and exactly `precision` digits after the decimal. If `precision` is 0, then the decimal is excluded. |
+| `e` | Y | `int` `uint` `double`: The value is converted to the style `[-]d.dddddde±dd` where there is one digit before the decimal and `precision` digits after the decimal followed by `e`, then the plus or minus, and then two digits. |
+| `x` `X` | N | Values are formatted in base 16. For `x` lowercase letters are used. For `X` uppercase letters are used.<table><tbody><tr><td><code>int</code> <code>uint</code></td><td>The value is formatted in base 16 with no insignificant digits. If the value was negative <code>-</code> is prepended.</td></tr><tr><td><code>string</code></td><td>The value is formatted as if `bytes(value)` was used to convert the <code>string</code> to <code>bytes</code> and then each byte is formatted in base 16 with exactly 2 digits.</td></tr><tr><td><code>bytes</code></td><td>The value is formatted as if each byte is formatted in base 16 with exactly 2 digits.</td></tr></tbody></table> |
+| `o` | N | `int` `uint`: The value is converted to base 8 with no insignificant digits. If the value was negative `-` is prepended. |
+| `b` | N | `int` `uint` `bool`: The value is converted to base 2 with no insignificant digits.  If the value was negative `-` is prepended. |
+
+> In all cases where `double` is accepted: if the value is NaN the result is `NaN`, if the value is infinity the result is `[-]Infinity`.
+
+### Examples
+
+```
+"%s".format(["foo"])  // foo
+"%s".format([b"foo"])  // foo
+"%d".format([1])      // 1
+"%d".format([1u])     // 1
+"%d".format([3.14])   // 3.14
+"%f".format([1])      // 1.000000
+"%f".format([1u])     // 1.000000
+"%f".format([3.14])   // 3.140000
+"%.1f".format([3.14])   // 3.1
+"%e".format([1])      // 1.000000e+00
+"%e".format([1u])     // 1.000000e+00
+"%e".format([3.14])   // 3.140000e+00
+"%.1e".format([3.14])   // 3.1e+00
+"%.1e".format([-3.14])   // -3.1e+00
+```
diff --git a/tests/simple/testdata/string_ext.textproto b/tests/simple/testdata/string_ext.textproto
@@ -524,7 +524,7 @@ section: {
     name: "scientific notation formatting clause"
     expr: '"%.6e".format([1052.032911275])'
     value: {
-      string_value: '1.052033×10⁰³',
+      string_value: '1.052033e+03',
     }
   }
   test: {
@@ -538,14 +538,49 @@ section: {
     name: "default precision for scientific notation"
     expr: '"%e".format([2.71828])'
     value: {
-      string_value: '2.718280×10⁰⁰',
+      string_value: '2.718280e+00',
     }
   }
   test: {
-    name: "unicode output for scientific notation"
-    expr: '"unescaped unicode: %e, escaped unicode: %e".format([2.71828, 2.71828])'
+    name: "NaN support for scientific notation"
+    expr: '"%e".format(["NaN"])'
     value: {
-      string_value: 'unescaped unicode: 2.718280×10⁰⁰, escaped unicode: 2.718280\u00d710\u2070\u2070',
+      string_value: 'NaN',
+    }
+  }
+  test: {
+    name: "positive infinity support for scientific notation"
+    expr: '"%e".format([double("Infinity")])'
+    value: {
+      string_value: 'Infinity',
+    }
+  }
+  test: {
+    name: "negative infinity support for scientific notation"
+    expr: '"%e".format([double("-Infinity")])'
+    value: {
+      string_value: '-Infinity',
+    }
+  }
+  test: {
+    name: "NaN support for decimal"
+    expr: '"%d".format(["NaN"])'
+    value: {
+      string_value: 'NaN',
+    }
+  }
+  test: {
+    name: "positive infinity support for decimal"
+    expr: '"%d".format([double("Infinity")])'
+    value: {
+      string_value: 'Infinity',
+    }
+  }
+  test: {
+    name: "negative infinity support for decimal"
+    expr: '"%d".format([double("-Infinity")])'
+    value: {
+      string_value: '-Infinity',
     }
   }
   test: {
@@ -557,16 +592,16 @@ section: {
   }
   test: {
     name: "positive infinity support for fixed-point"
-    expr: '"%f".format(["Infinity"])'
+    expr: '"%f".format([double("Infinity")])'
     value: {
-      string_value: '∞',
+      string_value: 'Infinity',
     }
   }
   test: {
     name: "negative infinity support for fixed-point"
-    expr: '"%f".format(["-Infinity"])'
+    expr: '"%f".format([double("-Infinity")])'
     value: {
-      string_value: '-∞',
+      string_value: '-Infinity',
     }
   }
   test: {
@@ -578,9 +613,9 @@ section: {
   }
   test: {
     name: "null support for string"
-    expr: '"null: %s".format([null])'
+    expr: '"%s".format([null])'
     value: {
-      string_value: 'null: null',
+      string_value: 'null',
     }
   }
   test: {
@@ -592,16 +627,16 @@ section: {
   }
   test: {
     name: "bytes support for string"
-    expr: '"some bytes: %s".format([b"xyz"])'
+    expr: '"%s".format([b"xyz"])'
     value: {
-      string_value: 'some bytes: xyz',
+      string_value: 'xyz',
     }
   }
   test: {
     name: "type() support for string"
-    expr: '"type is %s".format([type("test string")])'
+    expr: '"%s".format([type("test string")])'
     value: {
-      string_value: 'type is string',
+      string_value: 'string',
     }
   }
   test: {
@@ -620,135 +655,128 @@ section: {
   }
   test: {
     name: "list support for string"
-    expr: '"%s".format([["abc", 3.14, null, [9, 8, 7, 6], timestamp("2023-02-03T23:31:20Z")]])'
+    expr: '"%s".format([[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]])'
     value: {
-      string_value: '["abc", 3.14, null, [9, 8, 7, 6], timestamp("2023-02-03T23:31:20Z")]',
+      string_value: '[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]',
     }
   }
   test: {
     name: "map support for string"
     expr: '"%s".format([{"key1": b"xyz", "key5": null, "key2": duration("2h"), "key4": true, "key3": 2.71828}])'
     value: {
-      string_value: '{"key1":b"xyz", "key2":duration("7200s"), "key3":2.71828, "key4":true, "key5":null}',
+      string_value: '{key1: xyz, key2: 7200s, key3: 2.71828, key4: true, key5: null}',
     }
   }
   test: {
     name: "map support (all key types)"
-    expr: '"map with multiple key types: %s".format([{1: "value1", uint(2): "value2", true: double("NaN")}])'
+    expr: '"%s".format([{1: "value1", uint(2): "value2", true: double("NaN")}])'
     value: {
-      string_value: 'map with multiple key types: {1:"value1", 2:"value2", true:"NaN"}',
+      string_value: '{1: value1, 2: value2, true: NaN}',
     }
   }
   test: {
     name: "boolean support for %s"
-    expr: '"true bool: %s, false bool: %s".format([true, false])'
+    expr: '"%s, %s".format([true, false])'
     value: {
-      string_value: 'true bool: true, false bool: false',
+      string_value: 'true, false',
     }
   }
   test: {
       name: "dyntype support for string formatting clause"
-      expr: '"dynamic string: %s".format([dyn("a string")])'
+      expr: '"%s".format([dyn("a string")])'
       value: {
-          string_value: 'dynamic string: a string',
+          string_value: 'a string',
       }
   }
   test: {
     name: "dyntype support for numbers with string formatting clause"
-    expr: '"dynIntStr: %s dynDoubleStr: %s".format([dyn(32), dyn(56.8)])'
+    expr: '"%s, %s".format([dyn(32), dyn(56.8)])'
     value: {
-      string_value: 'dynIntStr: 32 dynDoubleStr: 56.8',
+      string_value: '32, 56.8',
     }
   }
   test: {
     name: "dyntype support for integer formatting clause"
-    expr: '"dynamic int: %d".format([dyn(128)])'
+    expr: '"%d".format([dyn(128)])'
     value: {
-      string_value: 'dynamic int: 128',
+      string_value: '128',
     }
   }
   test: {
     name: "dyntype support for integer formatting clause (unsigned)"
-    expr: '"dynamic unsigned int: %d".format([dyn(256u)])'
+    expr: '"%d".format([dyn(256u)])'
     value: {
-      string_value: 'dynamic unsigned int: 256',
+      string_value: '256',
     }
   }
   test: {
     name: "dyntype support for hex formatting clause"
-    expr: '"dynamic hex int: %x".format([dyn(22)])'
+    expr: '"%x".format([dyn(22)])'
     value: {
-      string_value: 'dynamic hex int: 16',
+      string_value: '16',
     }
   }
   test: {
     name: "dyntype support for hex formatting clause (uppercase)"
-    expr: '"dynamic hex int: %X (uppercase)".format([dyn(26)])'
+    expr: '"%X".format([dyn(26)])'
     value: {
-      string_value: 'dynamic hex int: 1A (uppercase)',
+      string_value: '1A',
     }
   }
   test: {
     name: "dyntype support for unsigned hex formatting clause"
-    expr: '"dynamic hex int: %x (unsigned)".format([dyn(500u)])'
+    expr: '"%x".format([dyn(500u)])'
     value: {
-      string_value: 'dynamic hex int: 1f4 (unsigned)',
+      string_value: '1f4',
     }
   }
   test: {
     name: "dyntype support for fixed-point formatting clause"
-    expr: '"dynamic double: %.3f".format([dyn(4.5)])'
+    expr: '"%.3f".format([dyn(4.5)])'
     value: {
-      string_value: 'dynamic double: 4.500',
+      string_value: '4.500',
     }
   }
   test: {
     name: "dyntype support for scientific notation"
-    expr: '"(dyntype) e: %e".format([dyn(2.71828)])'
+    expr: '"%e".format([dyn(2.71828)])'
     value: {
-      string_value: '(dyntype) e: 2.718280×10⁰⁰',
+      string_value: '2.718280e+00',
     }
   }
   test: {
     name: "dyntype NaN/infinity support for fixed-point"
-    expr: '"NaN: %f, infinity: %f".format([dyn("NaN"), dyn("Infinity")])'
+    expr: '"NaN: %f, infinity: %f".format([double("NaN"), double("Infinity"), double("-Infinity")])'
     value: {
-      string_value: 'NaN: NaN, infinity: ∞',
+      string_value: 'NaN, Infinity, -Infinity',
     }
   }
   test: {
     name: "dyntype support for timestamp"
-    expr: '"dyntype timestamp: %s".format([dyn(timestamp("2009-11-10T23:00:00Z"))])'
+    expr: '"%s".format([dyn(timestamp("2009-11-10T23:00:00Z"))])'
     value: {
-      string_value: 'dyntype timestamp: 2009-11-10T23:00:00Z',
+      string_value: '2009-11-10T23:00:00Z',
     }
   }
   test: {
     name: "dyntype support for duration"
-    expr: '"dyntype duration: %s".format([dyn(duration("8747s"))])'
+    expr: '"%s".format([dyn(duration("8747s"))])'
     value: {
-      string_value: 'dyntype duration: 8747s',
+      string_value: '8747s',
     }
   }
   test: {
     name: "dyntype support for lists"
-    expr: '"dyntype list: %s".format([dyn([6, 4.2, "a string"])])'
+    expr: '"%s".format([dyn([6, 4.2, "a string"])])'
     value: {
-      string_value: 'dyntype list: [6, 4.2, "a string"]',
+      string_value: '[6, 4.2, a string]',
     }
   }
   test: {
     name: "dyntype support for maps"
-    expr: '"dyntype map: %s".format([{"strKey":"x", 6:duration("422s"), true:42}])'
+    expr: '"%s".format([{"strKey":"x", 6:duration("422s"), true:42}])'
     value: {
-      string_value: 'dyntype map: {"strKey":"x", 6:duration("422s"), true:42}',
-    }
-  }
-  test: {
-    name: "message field support"
-    expr: '"message field msg.single_int32: %d, msg.single_double: %.1f".format([2, 1.0])'
-    value: {
-      string_value: 'message field msg.single_int32: 2, msg.single_double: 1.0',
+      string_value: '{strKey: x, 6: 422s, true: 42}',
     }
   }
   test: {
@@ -760,10 +788,10 @@ section: {
     }
     bindings: {
       key: "str_var"
-      value: { value: { string_value: "str is %s and some more" } }
+      value: { value: { string_value: "%s" } }
     }
     value: {
-      string_value: 'str is filler and some more',
+      string_value: 'filler',
     }
   }
   test: {
@@ -820,10 +848,10 @@ section: {
     }
     bindings: {
       key: "str_var"
-      value: { value: { string_value: "this is 5 in binary: %b" } }
+      value: { value: { string_value: "%b" } }
     }
     value: {
-      string_value: 'this is 5 in binary: 101',
+      string_value: '101',
     }
   }
   test: {
@@ -838,7 +866,7 @@ section: {
       value: { value: { string_value: "%.6e" } }
     }
     value: {
-      string_value: '1.052033×10⁰³',
+      string_value: '1.052033e+03',
     }
   }
   test: {

Original file line number	Diff line number	Diff line change
`@@ -524,7 +524,7 @@ section: {`
`524`	`524`	`name: "scientific notation formatting clause"`
`525`	`525`	`expr: '"%.6e".format([1052.032911275])'`
`526`	`526`	`value: {`
`527`		`- string_value: '1.052033×10⁰³',`
	`527`	`+ string_value: '1.052033e+03',`
`528`	`528`	`}`
`529`	`529`	`}`
`530`	`530`	`test: {`
`@@ -538,14 +538,49 @@ section: {`
`538`	`538`	`name: "default precision for scientific notation"`
`539`	`539`	`expr: '"%e".format([2.71828])'`
`540`	`540`	`value: {`
`541`		`- string_value: '2.718280×10⁰⁰',`
	`541`	`+ string_value: '2.718280e+00',`
`542`	`542`	`}`
`543`	`543`	`}`
`544`	`544`	`test: {`
`545`		`- name: "unicode output for scientific notation"`
`546`		`- expr: '"unescaped unicode: %e, escaped unicode: %e".format([2.71828, 2.71828])'`
	`545`	`+ name: "NaN support for scientific notation"`
	`546`	`+ expr: '"%e".format(["NaN"])'`
`547`	`547`	`value: {`
`548`		`- string_value: 'unescaped unicode: 2.718280×10⁰⁰, escaped unicode: 2.718280\u00d710\u2070\u2070',`
	`548`	`+ string_value: 'NaN',`
	`549`	`+ }`
	`550`	`+ }`
	`551`	`+ test: {`
	`552`	`+ name: "positive infinity support for scientific notation"`
	`553`	`+ expr: '"%e".format([double("Infinity")])'`
	`554`	`+ value: {`
	`555`	`+ string_value: 'Infinity',`
	`556`	`+ }`
	`557`	`+ }`
	`558`	`+ test: {`
	`559`	`+ name: "negative infinity support for scientific notation"`
	`560`	`+ expr: '"%e".format([double("-Infinity")])'`
	`561`	`+ value: {`
	`562`	`+ string_value: '-Infinity',`
	`563`	`+ }`
	`564`	`+ }`
	`565`	`+ test: {`
	`566`	`+ name: "NaN support for decimal"`
	`567`	`+ expr: '"%d".format(["NaN"])'`
	`568`	`+ value: {`
	`569`	`+ string_value: 'NaN',`
	`570`	`+ }`
	`571`	`+ }`
	`572`	`+ test: {`
	`573`	`+ name: "positive infinity support for decimal"`
	`574`	`+ expr: '"%d".format([double("Infinity")])'`
	`575`	`+ value: {`
	`576`	`+ string_value: 'Infinity',`
	`577`	`+ }`
	`578`	`+ }`
	`579`	`+ test: {`
	`580`	`+ name: "negative infinity support for decimal"`
	`581`	`+ expr: '"%d".format([double("-Infinity")])'`
	`582`	`+ value: {`
	`583`	`+ string_value: '-Infinity',`
`549`	`584`	`}`
`550`	`585`	`}`
`551`	`586`	`test: {`
`@@ -557,16 +592,16 @@ section: {`
`557`	`592`	`}`
`558`	`593`	`test: {`
`559`	`594`	`name: "positive infinity support for fixed-point"`
`560`		`- expr: '"%f".format(["Infinity"])'`
	`595`	`+ expr: '"%f".format([double("Infinity")])'`
`561`	`596`	`value: {`
`562`		`- string_value: '∞',`
	`597`	`+ string_value: 'Infinity',`
`563`	`598`	`}`
`564`	`599`	`}`
`565`	`600`	`test: {`
`566`	`601`	`name: "negative infinity support for fixed-point"`
`567`		`- expr: '"%f".format(["-Infinity"])'`
	`602`	`+ expr: '"%f".format([double("-Infinity")])'`
`568`	`603`	`value: {`
`569`		`- string_value: '-∞',`
	`604`	`+ string_value: '-Infinity',`
`570`	`605`	`}`
`571`	`606`	`}`
`572`	`607`	`test: {`
`@@ -578,9 +613,9 @@ section: {`
`578`	`613`	`}`
`579`	`614`	`test: {`
`580`	`615`	`name: "null support for string"`
`581`		`- expr: '"null: %s".format([null])'`
	`616`	`+ expr: '"%s".format([null])'`
`582`	`617`	`value: {`
`583`		`- string_value: 'null: null',`
	`618`	`+ string_value: 'null',`
`584`	`619`	`}`
`585`	`620`	`}`
`586`	`621`	`test: {`
`@@ -592,16 +627,16 @@ section: {`
`592`	`627`	`}`
`593`	`628`	`test: {`
`594`	`629`	`name: "bytes support for string"`
`595`		`- expr: '"some bytes: %s".format([b"xyz"])'`
	`630`	`+ expr: '"%s".format([b"xyz"])'`
`596`	`631`	`value: {`
`597`		`- string_value: 'some bytes: xyz',`
	`632`	`+ string_value: 'xyz',`
`598`	`633`	`}`
`599`	`634`	`}`
`600`	`635`	`test: {`
`601`	`636`	`name: "type() support for string"`
`602`		`- expr: '"type is %s".format([type("test string")])'`
	`637`	`+ expr: '"%s".format([type("test string")])'`
`603`	`638`	`value: {`
`604`		`- string_value: 'type is string',`
	`639`	`+ string_value: 'string',`
`605`	`640`	`}`
`606`	`641`	`}`
`607`	`642`	`test: {`
`@@ -620,135 +655,128 @@ section: {`
`620`	`655`	`}`
`621`	`656`	`test: {`
`622`	`657`	`name: "list support for string"`
`623`		`- expr: '"%s".format([["abc", 3.14, null, [9, 8, 7, 6], timestamp("2023-02-03T23:31:20Z")]])'`
	`658`	`+ expr: '"%s".format([[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]])'`
`624`	`659`	`value: {`
`625`		`- string_value: '["abc", 3.14, null, [9, 8, 7, 6], timestamp("2023-02-03T23:31:20Z")]',`
	`660`	`+ string_value: '[abc, 3.14, null, [9, 8, 7, 6], 2023-02-03T23:31:20Z]',`
`626`	`661`	`}`
`627`	`662`	`}`
`628`	`663`	`test: {`
`629`	`664`	`name: "map support for string"`
`630`	`665`	`expr: '"%s".format([{"key1": b"xyz", "key5": null, "key2": duration("2h"), "key4": true, "key3": 2.71828}])'`
`631`	`666`	`value: {`
`632`		`- string_value: '{"key1":b"xyz", "key2":duration("7200s"), "key3":2.71828, "key4":true, "key5":null}',`
	`667`	`+ string_value: '{key1: xyz, key2: 7200s, key3: 2.71828, key4: true, key5: null}',`
`633`	`668`	`}`
`634`	`669`	`}`
`635`	`670`	`test: {`
`636`	`671`	`name: "map support (all key types)"`
`637`		`- expr: '"map with multiple key types: %s".format([{1: "value1", uint(2): "value2", true: double("NaN")}])'`
	`672`	`+ expr: '"%s".format([{1: "value1", uint(2): "value2", true: double("NaN")}])'`
`638`	`673`	`value: {`
`639`		`- string_value: 'map with multiple key types: {1:"value1", 2:"value2", true:"NaN"}',`
	`674`	`+ string_value: '{1: value1, 2: value2, true: NaN}',`
`640`	`675`	`}`
`641`	`676`	`}`
`642`	`677`	`test: {`
`643`	`678`	`name: "boolean support for %s"`
`644`		`- expr: '"true bool: %s, false bool: %s".format([true, false])'`
	`679`	`+ expr: '"%s, %s".format([true, false])'`
`645`	`680`	`value: {`
`646`		`- string_value: 'true bool: true, false bool: false',`
	`681`	`+ string_value: 'true, false',`
`647`	`682`	`}`
`648`	`683`	`}`
`649`	`684`	`test: {`
`650`	`685`	`name: "dyntype support for string formatting clause"`
`651`		`- expr: '"dynamic string: %s".format([dyn("a string")])'`
	`686`	`+ expr: '"%s".format([dyn("a string")])'`
`652`	`687`	`value: {`
`653`		`- string_value: 'dynamic string: a string',`
	`688`	`+ string_value: 'a string',`
`654`	`689`	`}`
`655`	`690`	`}`
`656`	`691`	`test: {`
`657`	`692`	`name: "dyntype support for numbers with string formatting clause"`
`658`		`- expr: '"dynIntStr: %s dynDoubleStr: %s".format([dyn(32), dyn(56.8)])'`
	`693`	`+ expr: '"%s, %s".format([dyn(32), dyn(56.8)])'`
`659`	`694`	`value: {`
`660`		`- string_value: 'dynIntStr: 32 dynDoubleStr: 56.8',`
	`695`	`+ string_value: '32, 56.8',`
`661`	`696`	`}`
`662`	`697`	`}`
`663`	`698`	`test: {`
`664`	`699`	`name: "dyntype support for integer formatting clause"`
`665`		`- expr: '"dynamic int: %d".format([dyn(128)])'`
	`700`	`+ expr: '"%d".format([dyn(128)])'`
`666`	`701`	`value: {`
`667`		`- string_value: 'dynamic int: 128',`
	`702`	`+ string_value: '128',`
`668`	`703`	`}`
`669`	`704`	`}`
`670`	`705`	`test: {`
`671`	`706`	`name: "dyntype support for integer formatting clause (unsigned)"`
`672`		`- expr: '"dynamic unsigned int: %d".format([dyn(256u)])'`
	`707`	`+ expr: '"%d".format([dyn(256u)])'`
`673`	`708`	`value: {`
`674`		`- string_value: 'dynamic unsigned int: 256',`
	`709`	`+ string_value: '256',`
`675`	`710`	`}`
`676`	`711`	`}`
`677`	`712`	`test: {`
`678`	`713`	`name: "dyntype support for hex formatting clause"`
`679`		`- expr: '"dynamic hex int: %x".format([dyn(22)])'`
	`714`	`+ expr: '"%x".format([dyn(22)])'`
`680`	`715`	`value: {`
`681`		`- string_value: 'dynamic hex int: 16',`
	`716`	`+ string_value: '16',`
`682`	`717`	`}`
`683`	`718`	`}`
`684`	`719`	`test: {`
`685`	`720`	`name: "dyntype support for hex formatting clause (uppercase)"`
`686`		`- expr: '"dynamic hex int: %X (uppercase)".format([dyn(26)])'`
	`721`	`+ expr: '"%X".format([dyn(26)])'`
`687`	`722`	`value: {`
`688`		`- string_value: 'dynamic hex int: 1A (uppercase)',`
	`723`	`+ string_value: '1A',`
`689`	`724`	`}`
`690`	`725`	`}`
`691`	`726`	`test: {`
`692`	`727`	`name: "dyntype support for unsigned hex formatting clause"`
`693`		`- expr: '"dynamic hex int: %x (unsigned)".format([dyn(500u)])'`
	`728`	`+ expr: '"%x".format([dyn(500u)])'`
`694`	`729`	`value: {`
`695`		`- string_value: 'dynamic hex int: 1f4 (unsigned)',`
	`730`	`+ string_value: '1f4',`
`696`	`731`	`}`
`697`	`732`	`}`
`698`	`733`	`test: {`
`699`	`734`	`name: "dyntype support for fixed-point formatting clause"`
`700`		`- expr: '"dynamic double: %.3f".format([dyn(4.5)])'`
	`735`	`+ expr: '"%.3f".format([dyn(4.5)])'`
`701`	`736`	`value: {`
`702`		`- string_value: 'dynamic double: 4.500',`
	`737`	`+ string_value: '4.500',`
`703`	`738`	`}`
`704`	`739`	`}`
`705`	`740`	`test: {`
`706`	`741`	`name: "dyntype support for scientific notation"`
`707`		`- expr: '"(dyntype) e: %e".format([dyn(2.71828)])'`
	`742`	`+ expr: '"%e".format([dyn(2.71828)])'`
`708`	`743`	`value: {`
`709`		`- string_value: '(dyntype) e: 2.718280×10⁰⁰',`
	`744`	`+ string_value: '2.718280e+00',`
`710`	`745`	`}`
`711`	`746`	`}`
`712`	`747`	`test: {`
`713`	`748`	`name: "dyntype NaN/infinity support for fixed-point"`
`714`		`- expr: '"NaN: %f, infinity: %f".format([dyn("NaN"), dyn("Infinity")])'`
	`749`	`+ expr: '"NaN: %f, infinity: %f".format([double("NaN"), double("Infinity"), double("-Infinity")])'`
`715`	`750`	`value: {`
`716`		`- string_value: 'NaN: NaN, infinity: ∞',`
	`751`	`+ string_value: 'NaN, Infinity, -Infinity',`
`717`	`752`	`}`
`718`	`753`	`}`
`719`	`754`	`test: {`
`720`	`755`	`name: "dyntype support for timestamp"`
`721`		`- expr: '"dyntype timestamp: %s".format([dyn(timestamp("2009-11-10T23:00:00Z"))])'`
	`756`	`+ expr: '"%s".format([dyn(timestamp("2009-11-10T23:00:00Z"))])'`
`722`	`757`	`value: {`
`723`		`- string_value: 'dyntype timestamp: 2009-11-10T23:00:00Z',`
	`758`	`+ string_value: '2009-11-10T23:00:00Z',`
`724`	`759`	`}`
`725`	`760`	`}`
`726`	`761`	`test: {`
`727`	`762`	`name: "dyntype support for duration"`
`728`		`- expr: '"dyntype duration: %s".format([dyn(duration("8747s"))])'`
	`763`	`+ expr: '"%s".format([dyn(duration("8747s"))])'`
`729`	`764`	`value: {`
`730`		`- string_value: 'dyntype duration: 8747s',`
	`765`	`+ string_value: '8747s',`
`731`	`766`	`}`
`732`	`767`	`}`
`733`	`768`	`test: {`
`734`	`769`	`name: "dyntype support for lists"`
`735`		`- expr: '"dyntype list: %s".format([dyn([6, 4.2, "a string"])])'`
	`770`	`+ expr: '"%s".format([dyn([6, 4.2, "a string"])])'`
`736`	`771`	`value: {`
`737`		`- string_value: 'dyntype list: [6, 4.2, "a string"]',`
	`772`	`+ string_value: '[6, 4.2, a string]',`
`738`	`773`	`}`
`739`	`774`	`}`
`740`	`775`	`test: {`
`741`	`776`	`name: "dyntype support for maps"`
`742`		`- expr: '"dyntype map: %s".format([{"strKey":"x", 6:duration("422s"), true:42}])'`
	`777`	`+ expr: '"%s".format([{"strKey":"x", 6:duration("422s"), true:42}])'`
`743`	`778`	`value: {`
`744`		`- string_value: 'dyntype map: {"strKey":"x", 6:duration("422s"), true:42}',`
`745`		`- }`
`746`		`- }`
`747`		`- test: {`
`748`		`- name: "message field support"`
`749`		`- expr: '"message field msg.single_int32: %d, msg.single_double: %.1f".format([2, 1.0])'`
`750`		`- value: {`
`751`		`- string_value: 'message field msg.single_int32: 2, msg.single_double: 1.0',`
	`779`	`+ string_value: '{strKey: x, 6: 422s, true: 42}',`
`752`	`780`	`}`
`753`	`781`	`}`
`754`	`782`	`test: {`
`@@ -760,10 +788,10 @@ section: {`
`760`	`788`	`}`
`761`	`789`	`bindings: {`
`762`	`790`	`key: "str_var"`
`763`		`- value: { value: { string_value: "str is %s and some more" } }`
	`791`	`+ value: { value: { string_value: "%s" } }`
`764`	`792`	`}`
`765`	`793`	`value: {`
`766`		`- string_value: 'str is filler and some more',`
	`794`	`+ string_value: 'filler',`
`767`	`795`	`}`
`768`	`796`	`}`
`769`	`797`	`test: {`
`@@ -820,10 +848,10 @@ section: {`
`820`	`848`	`}`
`821`	`849`	`bindings: {`
`822`	`850`	`key: "str_var"`
`823`		`- value: { value: { string_value: "this is 5 in binary: %b" } }`
	`851`	`+ value: { value: { string_value: "%b" } }`
`824`	`852`	`}`
`825`	`853`	`value: {`
`826`		`- string_value: 'this is 5 in binary: 101',`
	`854`	`+ string_value: '101',`
`827`	`855`	`}`
`828`	`856`	`}`
`829`	`857`	`test: {`
`@@ -838,7 +866,7 @@ section: {`
`838`	`866`	`value: { value: { string_value: "%.6e" } }`
`839`	`867`	`}`
`840`	`868`	`value: {`
`841`		`- string_value: '1.052033×10⁰³',`
	`869`	`+ string_value: '1.052033e+03',`
`842`	`870`	`}`
`843`	`871`	`}`
`844`	`872`	`test: {`