one 1.1.520 → 1.1.522

package/src/fork/__tests__/getStateFromPath.test.tsx

@@ -94,9 +94,7 @@ test.skip('decodes encoded params in path', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getPathFromState<object>(getStateFromPath<object>(path, config)!, config)
-  ).toEqual(path)
+  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toEqual(path)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -133,9 +131,7 @@ test.skip('decodes encoded params in path that have encoded /', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getPathFromState<object>(getStateFromPath<object>(path, config)!, config)
-  ).toEqual(path)
+  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toEqual(path)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -152,8 +148,7 @@ test.skip('converts path string to initial state with config', () => {
               Baz: {
                 path: 'baz/:author',
                 parse: {
-                  author: (author: string) =>
-                    author.replace(/^\w/, (c) => c.toUpperCase()),
+                  author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
                   count: Number,
                   valid: Boolean,
                 },
@@ -199,9 +194,7 @@ test.skip('converts path string to initial state with config', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('handles leading slash when converting', () => {
@@ -283,8 +276,7 @@ test.skip('converts path string to initial state with config with nested screens
                   Baz: {
                     path: 'baz/:author',
                     parse: {
-                      author: (author: string) =>
-                        author.replace(/^\w/, (c) => c.toUpperCase()),
+                      author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
                       count: Number,
                       valid: Boolean,
                     },
@@ -339,9 +331,7 @@ test.skip('converts path string to initial state with config with nested screens
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -359,8 +349,7 @@ test.skip('converts path string to initial state with config with nested screens
               Baz: {
                 path: 'baz/:author',
                 parse: {
-                  author: (author: string) =>
-                    author.replace(/^\w/, (c) => c.toUpperCase()),
+                  author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
                   count: Number,
                   valid: Boolean,
                   id: Boolean,
@@ -403,9 +392,9 @@ test.skip('converts path string to initial state with config with nested screens
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/foe/baz/Jane?count=10&answer=42&valid=true'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/foe/baz/Jane?count=10&answer=42&valid=true')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -430,12 +419,10 @@ test.skip('handles nested object with unused configs and with parse in it', () =
                       Bis: {
                         path: 'bis/:author',
                         stringify: {
-                          author: (author: string) =>
-                            author.replace(/^\w/, (c) => c.toLowerCase()),
+                          author: (author: string) => author.replace(/^\w/, (c) => c.toLowerCase()),
                         },
                         parse: {
-                          author: (author: string) =>
-                            author.replace(/^\w/, (c) => c.toUpperCase()),
+                          author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
                           count: Number,
                           valid: Boolean,
                         },
@@ -496,9 +483,7 @@ test.skip('handles nested object with unused configs and with parse in it', () =
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('handles parse in nested object for second route depth', () => {
@@ -546,9 +531,7 @@ test('handles parse in nested object for second route depth', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('handles parse in nested object for second route depth and and path and parse in roots', () => {
@@ -597,9 +580,7 @@ test('handles parse in nested object for second route depth and and path and par
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -634,9 +615,7 @@ test.skip('handles path at top level', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('handles initialRouteName at top level', () => {
@@ -678,9 +657,7 @@ test('handles initialRouteName at top level', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('handles initialRouteName inside a screen', () => {
@@ -724,9 +701,7 @@ test('handles initialRouteName inside a screen', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('handles initialRouteName included in path', () => {
@@ -766,9 +741,7 @@ test('handles initialRouteName included in path', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -794,12 +767,10 @@ test.skip('handles two initialRouteNames', () => {
                       Bis: {
                         path: 'bis/:author',
                         stringify: {
-                          author: (author: string) =>
-                            author.replace(/^\w/, (c) => c.toLowerCase()),
+                          author: (author: string) => author.replace(/^\w/, (c) => c.toLowerCase()),
                         },
                         parse: {
-                          author: (author: string) =>
-                            author.replace(/^\w/, (c) => c.toUpperCase()),
+                          author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
                           count: Number,
                           valid: Boolean,
                         },
@@ -862,9 +833,7 @@ test.skip('handles two initialRouteNames', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -890,12 +859,10 @@ test.skip('accepts initialRouteName without config for it', () => {
                       Bis: {
                         path: 'bis/:author',
                         stringify: {
-                          author: (author: string) =>
-                            author.replace(/^\w/, (c) => c.toLowerCase()),
+                          author: (author: string) => author.replace(/^\w/, (c) => c.toLowerCase()),
                         },
                         parse: {
-                          author: (author: string) =>
-                            author.replace(/^\w/, (c) => c.toUpperCase()),
+                          author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
                           count: Number,
                           valid: Boolean,
                         },
@@ -958,9 +925,7 @@ test.skip('accepts initialRouteName without config for it', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('returns undefined if no matching screen is present (top level path)', () => {
@@ -1063,9 +1028,9 @@ test.skip('returns matching screen if path is empty', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, ''))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1106,9 +1071,9 @@ test.skip('returns matching screen if path is only slash', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, ''))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '')
+  )
 })
 
 test('returns matching screen with params if path is empty', () => {
@@ -1151,9 +1116,9 @@ test('returns matching screen with params if path is empty', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/?foo=42'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/?foo=42')
+  )
 })
 
 test("doesn't match nested screen if path is empty", () => {
@@ -1225,9 +1190,7 @@ test.skip('chooses more exhaustive pattern', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('handles same paths beginnings', () => {
@@ -1269,9 +1232,7 @@ test('handles same paths beginnings', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1318,9 +1279,7 @@ test.skip('handles same paths beginnings with params', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1374,9 +1333,7 @@ test.skip('handles not taking path with too many segments', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1430,9 +1387,7 @@ test.skip('handles differently ordered params v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1486,9 +1441,7 @@ test.skip('handles differently ordered params v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1542,9 +1495,7 @@ test.skip('handles differently ordered params v3', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1598,9 +1549,9 @@ test.skip('handles differently ordered params v4', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/5/foos/res/20'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/5/foos/res/20')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1654,9 +1605,7 @@ test.skip('handles simple optional params', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1710,9 +1659,7 @@ test.skip('handle 2 optional params at the end v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1766,9 +1713,7 @@ test.skip('handle 2 optional params at the end v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1823,9 +1768,7 @@ test.skip('handle 2 optional params at the end v3', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1880,9 +1823,7 @@ test.skip('handle optional params in the middle v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1937,9 +1878,7 @@ test.skip('handle optional params in the middle v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1995,9 +1934,7 @@ test.skip('handle optional params in the middle v3', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2053,9 +1990,7 @@ test.skip('handle optional params in the middle v4', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2111,9 +2046,7 @@ test.skip('handle optional params in the middle v5', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2169,9 +2102,9 @@ test.skip('handle optional params in the beginning v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/5/10/foos/15'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/5/10/foos/15')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2227,9 +2160,9 @@ test.skip('handle optional params in the beginning v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/5/10/foos/15'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/5/10/foos/15')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2269,9 +2202,9 @@ test.skip('merges parent patterns if needed', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/foo/42/baz/babel'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/foo/42/baz/babel')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2307,9 +2240,7 @@ test.skip('ignores extra slashes in the pattern', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2333,9 +2264,9 @@ test.skip('matches wildcard patterns at root', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/404'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/404')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2376,9 +2307,9 @@ test.skip('matches wildcard patterns at nested level', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/bar/42/404'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/bar/42/404')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2422,9 +2353,9 @@ test.skip('matches wildcard patterns at nested level with exact', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/404'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/404')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2467,9 +2398,7 @@ test.skip('tries to match wildcard patterns at the end', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2503,9 +2432,9 @@ test.skip('uses nearest parent wildcard match for unmatched paths', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/404'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/404')
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2539,9 +2468,9 @@ test.skip('matches screen with overlapping initial path and wildcard', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(changePath(state, '/bar/42/Baz'))
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
+    changePath(state, '/bar/42/Baz')
+  )
 })
 
 test('throws if two screens map to the same pattern', () => {
@@ -2636,9 +2565,7 @@ test('correctly applies initialRouteName for config with similar route names', (
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 test('correctly applies initialRouteName for config with similar route names v2', () => {
@@ -2696,9 +2623,7 @@ test('correctly applies initialRouteName for config with similar route names v2'
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(
-    getStateFromPath<object>(getPathFromState<object>(state, config), config)
-  ).toEqual(state)
+  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2813,9 +2738,7 @@ test.skip('encodes special characters in params', () => {
   }
 
   expect(getPathFromState<object>(state, config)).toBe(`/${path}`)
-  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toBe(
-    `/${path}`
-  )
+  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toBe(`/${path}`)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2869,9 +2792,7 @@ test('parses / same as empty string', () => {
     },
   }
 
-  expect(getStateFromPath<object>('/', config)).toEqual(
-    getStateFromPath<object>('', config)
-  )
+  expect(getStateFromPath<object>('/', config)).toEqual(getStateFromPath<object>('', config))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -3052,17 +2973,13 @@ test.skip('handles alias for paths', () => {
     routes: [{ name: 'Foo', path: 'foo' }],
   })
 
-  expect(getPathFromState<object>(getStateFromPath<object>('foo', config)!, config)).toBe(
-    '/foo'
-  )
+  expect(getPathFromState<object>(getStateFromPath<object>('foo', config)!, config)).toBe('/foo')
 
   expect(getStateFromPath<object>('first', config)).toEqual({
     routes: [{ name: 'Foo', path: 'first' }],
   })
 
-  expect(
-    getPathFromState<object>(getStateFromPath<object>('first', config)!, config)
-  ).toBe('/foo')
+  expect(getPathFromState<object>(getStateFromPath<object>('first', config)!, config)).toBe('/foo')
 
   expect(getStateFromPath<object>('foo/baz/@$test', config)).toEqual({
     routes: [
@@ -3102,9 +3019,9 @@ test.skip('handles alias for paths', () => {
     ],
   })
 
-  expect(
-    getPathFromState<object>(getStateFromPath<object>('second/42', config)!, config)
-  ).toBe('/foo/baz/42')
+  expect(getPathFromState<object>(getStateFromPath<object>('second/42', config)!, config)).toBe(
+    '/foo/baz/42'
+  )
 
   expect(getStateFromPath<object>('foo/third', config)).toEqual({
     routes: [
@@ -3122,9 +3039,9 @@ test.skip('handles alias for paths', () => {
     ],
   })
 
-  expect(
-    getPathFromState<object>(getStateFromPath<object>('foo/third', config)!, config)
-  ).toBe('/foo/baz')
+  expect(getPathFromState<object>(getStateFromPath<object>('foo/third', config)!, config)).toBe(
+    '/foo/baz'
+  )
 
   expect(getStateFromPath<object>('foo/fourth/@$test', config)).toEqual({
     routes: [
@@ -3144,10 +3061,7 @@ test.skip('handles alias for paths', () => {
   })
 
   expect(
-    getPathFromState<object>(
-      getStateFromPath<object>('foo/fourth/@$test', config)!,
-      config
-    )
+    getPathFromState<object>(getStateFromPath<object>('foo/fourth/@$test', config)!, config)
   ).toBe('/foo/baz/@test')
 
   expect(getStateFromPath<object>('foo/qux/42', config)).toEqual({
@@ -3167,9 +3081,9 @@ test.skip('handles alias for paths', () => {
     ],
   })
 
-  expect(
-    getPathFromState<object>(getStateFromPath<object>('foo/qux/42', config)!, config)
-  ).toBe('/foo/qux/42')
+  expect(getPathFromState<object>(getStateFromPath<object>('foo/qux/42', config)!, config)).toBe(
+    '/foo/qux/42'
+  )
 })
 
 // @modify: TODO: temporally disable failing test