test(stdlib): add test for consecutive separators in unflatten function

src/stdlib/unflatten.rs

@@ -83,7 +83,9 @@ where
 // and avoid doing recursive calls to `do_unflatten_entries` with a single entry every time
 fn do_unflatten_entry(entry: (KeyString, Value), separator: &str, recursive: bool) -> Value {
     let (key, value) = entry;
+    dbg!(&key);
     let keys = key.split(separator).map(Into::into).collect::<Vec<_>>();
+    dbg!(&keys);
     let mut result = if recursive {
         do_unflatten(value, separator, recursive)
     } else {
@@ -361,17 +363,47 @@ mod test {
         consecutive_separators {
             args: func_args![value: value!({
                 "a..b": 1,
+                "a...c": 2,
             })],
             want: Ok(value!({
                 a: {
                     "": {
                         b: 1,
+                        "": {
+                            c: 2,
+                        },
                     },
                 },
             })),
             tdef: TypeDef::object(Collection::any()),
         }
 
+        traling_separator{
+            args: func_args![value: value!({
+                "a.": 1,
+            })],
+            want: Ok(value!({
+                a: {
+                    "": 1,
+                },
+            })),
+            tdef: TypeDef::object(Collection::any()),
+        }
+
+        consecutive_trailing_separator{
+            args: func_args![value: value!({
+                "a..": 1,
+            })],
+            want: Ok(value!({
+                a: {
+                    "": {
+                        "": 1,
+                    }
+                },
+            })),
+            tdef: TypeDef::object(Collection::any()),
+        }
+
         filter_out_top_level_value_when_multiple_values {
             args: func_args![value: value!({
                 "a.b": 1,