diff --git a/chaotic/src/chaotic/openapi/parameters_read_test.cpp b/chaotic/src/chaotic/openapi/parameters_read_test.cpp
index c11b4e162517..375a6ce21246 100644
--- a/chaotic/src/chaotic/openapi/parameters_read_test.cpp
+++ b/chaotic/src/chaotic/openapi/parameters_read_test.cpp
@@ -9,93 +9,108 @@ USERVER_NAMESPACE_BEGIN
 
 namespace co = chaotic::openapi;
 
+static constexpr co::Name kName{"foo"};
+
 UTEST(OpenapiParametersRead, SourceHttpRequest) {
-    auto request = server::http::HttpRequestBuilder()
-                       .AddRequestArg("foo", "bar")
-                       .AddRequestArg("foo", "baz")
-                       .AddHeader("foo", "header")
-                       .AddHeader("Cookie", "foo=cookie")
-                       .SetPathArgs({{"foo", "path"}})
-                       .Build();
-    const auto& source = *request;
-
-    static constexpr co::Name kName{"foo"};
-
-    auto query_multi = co::ReadParameter<co::ArrayParameter<co::In::kQueryExplode, kName, ',', std::string>>(source);
-    auto query = co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, std::string>>(source);
-    auto path = co::ReadParameter<co::TrivialParameter<co::In::kPath, kName, std::string>>(source);
-    auto header = co::ReadParameter<co::TrivialParameter<co::In::kHeader, kName, std::string>>(source);
-    auto cookie = co::ReadParameter<co::TrivialParameter<co::In::kCookie, kName, std::string>>(source);
-
-    EXPECT_EQ(query_multi, (std::vector<std::string>{"bar", "baz"}));
-    EXPECT_EQ(query, "bar");
-    EXPECT_EQ(path, "path");
-    EXPECT_EQ(header, "header");
-    EXPECT_EQ(cookie, "cookie");
+  auto request = server::http::HttpRequestBuilder()
+                     .AddRequestArg("foo", "bar")
+                     .AddRequestArg("foo", "baz")
+                     .AddHeader("foo", "header")
+                     .AddHeader("Cookie", "foo=cookie")
+                     .SetPathArgs({{"foo", "path"}})
+                     .Build();
+  const auto& source = *request;
+
+  auto query_multi = co::ReadParameter<
+      co::ArrayParameter<co::In::kQueryExplode, kName, ',', std::string>>(
+      source);
+  auto query = co::ReadParameter<
+      co::TrivialParameter<co::In::kQuery, kName, std::string>>(source);
+  auto path = co::ReadParameter<
+      co::TrivialParameter<co::In::kPath, kName, std::string>>(source);
+  auto header = co::ReadParameter<
+      co::TrivialParameter<co::In::kHeader, kName, std::string>>(source);
+  auto cookie = co::ReadParameter<
+      co::TrivialParameter<co::In::kCookie, kName, std::string>>(source);
+
+  EXPECT_EQ(query_multi, (std::vector<std::string>{"bar", "baz"}));
+  EXPECT_EQ(query, "bar");
+  EXPECT_EQ(path, "path");
+  EXPECT_EQ(header, "header");
+  EXPECT_EQ(cookie, "cookie");
 }
 
 UTEST(OpenapiParametersRead, TypeBoolean) {
-    auto request = server::http::HttpRequestBuilder().AddRequestArg("foo", "true").Build();
-    static constexpr co::Name kName{"foo"};
+  auto request =
+      server::http::HttpRequestBuilder().AddRequestArg("foo", "true").Build();
 
-    bool foo{co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, bool>>(*request)};
-    EXPECT_EQ(foo, true);
+  bool foo{co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, bool>>(
+      *request)};
+  EXPECT_EQ(foo, true);
 }
 
 UTEST(OpenapiParametersRead, TypeDouble) {
-    auto request = server::http::HttpRequestBuilder().AddRequestArg("foo", "12.2").Build();
-    static constexpr co::Name kName{"foo"};
+  auto request =
+      server::http::HttpRequestBuilder().AddRequestArg("foo", "12.2").Build();
 
-    double foo{co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, double>>(*request)};
-    EXPECT_EQ(foo, 12.2);
+  double foo{
+      co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, double>>(
+          *request)};
+  EXPECT_EQ(foo, 12.2);
 }
 
 UTEST(OpenapiParametersRead, UserType) {
-    auto request = server::http::HttpRequestBuilder().AddRequestArg("foo", "12.2").Build();
-    static constexpr co::Name kName{"foo"};
-
-    using Decimal = decimal64::Decimal<10>;
-    Decimal foo{co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, std::string, Decimal>>(*request)};
-    EXPECT_EQ(foo, Decimal{"12.2"});
+  auto request =
+      server::http::HttpRequestBuilder().AddRequestArg("foo", "12.2").Build();
+
+  using Decimal = decimal64::Decimal<10>;
+  Decimal foo{co::ReadParameter<
+      co::TrivialParameter<co::In::kQuery, kName, std::string, Decimal>>(
+      *request)};
+  EXPECT_EQ(foo, Decimal{"12.2"});
 }
 
 UTEST(OpenapiParametersRead, TypeInt) {
-    auto request = server::http::HttpRequestBuilder().AddRequestArg("foo", "12").Build();
-    static constexpr co::Name kName{"foo"};
+  auto request =
+      server::http::HttpRequestBuilder().AddRequestArg("foo", "12").Build();
 
-    int foo{co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, int>>(*request)};
-    EXPECT_EQ(foo, 12);
+  int foo{co::ReadParameter<co::TrivialParameter<co::In::kQuery, kName, int>>(
+      *request)};
+  EXPECT_EQ(foo, 12);
 }
 
 UTEST(OpenapiParametersRead, TypeArrayOfString) {
-    auto request = server::http::HttpRequestBuilder().AddRequestArg("foo", "bar,baz").Build();
-    static constexpr co::Name kName{"foo"};
+  auto request = server::http::HttpRequestBuilder()
+                     .AddRequestArg("foo", "bar,baz")
+                     .Build();
 
-    std::vector<std::string> foo{
-        co::ReadParameter<co::ArrayParameter<co::In::kQuery, kName, ',', std::string>>(*request)};
-    EXPECT_EQ(foo, (std::vector<std::string>{"bar", "baz"}));
+  std::vector<std::string> foo{co::ReadParameter<
+      co::ArrayParameter<co::In::kQuery, kName, ',', std::string>>(*request)};
+  EXPECT_EQ(foo, (std::vector<std::string>{"bar", "baz"}));
 }
 
 UTEST(OpenapiParametersRead, TypeArrayOfUser) {
-    auto request = server::http::HttpRequestBuilder().AddRequestArg("foo", "1.2,3.4").Build();
-    static constexpr co::Name kName{"foo"};
-
-    using Decimal = decimal64::Decimal<10>;
-    std::vector<Decimal> foo{
-        co::ReadParameter<co::ArrayParameter<co::In::kQuery, kName, ',', std::string, Decimal>>(*request)};
-    EXPECT_EQ(foo, (std::vector<Decimal>{Decimal{"1.2"}, Decimal{"3.4"}}));
+  auto request = server::http::HttpRequestBuilder()
+                     .AddRequestArg("foo", "1.2,3.4")
+                     .Build();
+
+  using Decimal = decimal64::Decimal<10>;
+  std::vector<Decimal> foo{co::ReadParameter<
+      co::ArrayParameter<co::In::kQuery, kName, ',', std::string, Decimal>>(
+      *request)};
+  EXPECT_EQ(foo, (std::vector<Decimal>{Decimal{"1.2"}, Decimal{"3.4"}}));
 }
 
 UTEST(OpenapiParametersRead, TypeStringExplode) {
-    auto request = server::http::HttpRequestBuilder()
-                       .AddRequestArg("foo", "1")
-                       .AddRequestArg("foo", "2")
-                       .AddRequestArg("foo", "3")
-                       .Build();
-    static constexpr co::Name kName{"foo"};
-
-    std::vector<int> foo{co::ReadParameter<co::ArrayParameter<co::In::kQueryExplode, kName, ',', int>>(*request)};
-    EXPECT_EQ(foo, (std::vector{1, 2, 3}));
+  auto request = server::http::HttpRequestBuilder()
+                     .AddRequestArg("foo", "1")
+                     .AddRequestArg("foo", "2")
+                     .AddRequestArg("foo", "3")
+                     .Build();
+
+  std::vector<int> foo{co::ReadParameter<
+      co::ArrayParameter<co::In::kQueryExplode, kName, ',', int>>(*request)};
+  EXPECT_EQ(foo, (std::vector{1, 2, 3}));
 }
 
 USERVER_NAMESPACE_END
diff --git a/chaotic/src/chaotic/openapi/parameters_write_test.cpp b/chaotic/src/chaotic/openapi/parameters_write_test.cpp
index 31435d746474..1c84936b7d75 100644
--- a/chaotic/src/chaotic/openapi/parameters_write_test.cpp
+++ b/chaotic/src/chaotic/openapi/parameters_write_test.cpp
@@ -14,213 +14,216 @@ USERVER_NAMESPACE_BEGIN
 namespace co = chaotic::openapi;
 
 class ParameterSinkMock : public co::ParameterSinkBase {
-public:
-    MOCK_METHOD(void, SetCookie, (std::string_view, std::string&&), (override));
+ public:
+  MOCK_METHOD(void, SetCookie, (std::string_view, std::string&&), (override));
 
-    MOCK_METHOD(void, SetHeader, (std::string_view, std::string&&), (override));
+  MOCK_METHOD(void, SetHeader, (std::string_view, std::string&&), (override));
 
-    MOCK_METHOD(void, SetPath, (co::Name&, std::string&&), (override));
+  MOCK_METHOD(void, SetPath, (co::Name&, std::string&&), (override));
 
-    MOCK_METHOD(void, SetQuery, (std::string_view, std::string&&), (override));
+  MOCK_METHOD(void, SetQuery, (std::string_view, std::string&&), (override));
 
-    MOCK_METHOD(void, SetMultiQuery, (std::string_view, std::vector<std::string>&&), (override));
+  MOCK_METHOD(void, SetMultiQuery,
+              (std::string_view, std::vector<std::string>&&), (override));
 };
 
-UTEST(OpenapiParameters, Cookie) {
-    static constexpr co::Name kName{"test"};
+static constexpr co::Name kTest{
+    "test",
+};
 
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetCookie("test", std::string{"value"}));
+UTEST(OpenapiParameters, Cookie) {
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetCookie(std::string_view{"test"}, std::string{"value"}));
 
-    co::WriteParameter<co::TrivialParameter<co::In::kCookie, kName, std::string>>("value", sink);
+  co::WriteParameter<co::TrivialParameter<co::In::kCookie, kTest, std::string>>(
+      "value", sink);
 }
 
 UTEST(OpenapiParameters, Path) {
-    static constexpr co::Name kName{"test"};
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetPath("test", std::string{"value"}));
 
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetPath("test", std::string{"value"}));
-
-    co::WriteParameter<co::TrivialParameter<co::In::kPath, kName, std::string>>("value", sink);
+  co::WriteParameter<co::TrivialParameter<co::In::kPath, kTest, std::string>>(
+      "value", sink);
 }
 
 UTEST(OpenapiParameters, Header) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetHeader("test", std::string{"value"}));
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetHeader(std::string_view{"test"}, std::string{"value"}));
 
-    co::WriteParameter<co::TrivialParameter<co::In::kHeader, kName, std::string>>("value", sink);
+  co::WriteParameter<co::TrivialParameter<co::In::kHeader, kTest, std::string>>(
+      "value", sink);
 }
 
 UTEST(OpenapiParameters, Query) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetQuery("test", std::string{"value"}));
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetQuery(std::string_view{"test"}, std::string{"value"}));
 
-    co::WriteParameter<co::TrivialParameter<co::In::kQuery, kName, std::string>>("value", sink);
+  co::WriteParameter<co::TrivialParameter<co::In::kQuery, kTest, std::string>>(
+      "value", sink);
 }
 
 UTEST(OpenapiParameters, QueryExplode) {
-    static constexpr co::Name kName{"test"};
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetMultiQuery(std::string_view{"test"},
+                                  (std::vector<std::string>{"foo", "bar"})));
 
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetMultiQuery("test", (std::vector<std::string>{"foo", "bar"})));
-
-    co::WriteParameter<co::ArrayParameter<co::In::kQueryExplode, kName, ',', std::string>>(
-        std::vector<std::string>{"foo", "bar"}, sink
-    );
+  co::WriteParameter<
+      co::ArrayParameter<co::In::kQueryExplode, kTest, ',', std::string>>(
+      std::vector<std::string>{"foo", "bar"}, sink);
 }
 
 UTEST(OpenapiParameters, QueryExplodeInteger) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetMultiQuery("test", (std::vector<std::string>{"1", "2"})));
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetMultiQuery(std::string_view{"test"},
+                                  (std::vector<std::string>{"1", "2"})));
 
-    co::WriteParameter<co::ArrayParameter<co::In::kQueryExplode, kName, ',', int>>(std::vector<int>{1, 2}, sink);
+  co::WriteParameter<
+      co::ArrayParameter<co::In::kQueryExplode, kTest, ',', int>>(
+      std::vector<int>{1, 2}, sink);
 }
 
 UTEST(OpenapiParameters, QueryExplodeUser) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetMultiQuery("test", (std::vector<std::string>{"1.2", "3.4"})));
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetMultiQuery(std::string_view{"test"},
+                                  (std::vector<std::string>{"1.2", "3.4"})));
 
-    using Decimal = decimal64::Decimal<10>;
-    co::WriteParameter<co::ArrayParameter<co::In::kQueryExplode, kName, ',', std::string, Decimal>>(
-        std::vector<Decimal>{Decimal{"1.2"}, Decimal{"3.4"}}, sink
-    );
+  using Decimal = decimal64::Decimal<10>;
+  co::WriteParameter<co::ArrayParameter<co::In::kQueryExplode, kTest, ',',
+                                        std::string, Decimal>>(
+      std::vector<Decimal>{Decimal{"1.2"}, Decimal{"3.4"}}, sink);
 }
 
 UTEST(OpenapiParameters, CookieArray) {
-    static constexpr co::Name kName{"test"};
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink,
+              SetCookie(std::string_view{"test"}, std::string{"foo,bar"}));
 
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetCookie("test", std::string{"foo,bar"}));
-
-    co::WriteParameter<co::ArrayParameter<co::In::kCookie, kName, ',', std::string, std::string>>({"foo", "bar"}, sink);
+  co::WriteParameter<co::ArrayParameter<co::In::kCookie, kTest, ',',
+                                        std::string, std::string>>(
+      {"foo", "bar"}, sink);
 }
 
 UTEST(OpenapiParameters, QueryArrayOfInteger) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetQuery("test", std::string{"1,2"}));
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetQuery(std::string_view{"test"}, std::string{"1,2"}));
 
-    co::WriteParameter<co::ArrayParameter<co::In::kQuery, kName, ',', int>>({1, 2}, sink);
+  co::WriteParameter<co::ArrayParameter<co::In::kQuery, kTest, ',', int>>(
+      {1, 2}, sink);
 }
 
 UTEST(OpenapiParameters, QueryArrayOfUserTypes) {
-    static constexpr co::Name kName{"test"};
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetQuery(std::string_view{"test"}, std::string{"1.1,2.2"}));
 
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetQuery("test", std::string{"1.1,2.2"}));
-
-    using Decimal = decimal64::Decimal<10>;
-    co::WriteParameter<co::ArrayParameter<co::In::kQuery, kName, ',', std::string, Decimal>>(
-        {Decimal{"1.1"}, Decimal{"2.2"}}, sink
-    );
+  using Decimal = decimal64::Decimal<10>;
+  co::WriteParameter<
+      co::ArrayParameter<co::In::kQuery, kTest, ',', std::string, Decimal>>(
+      {Decimal{"1.1"}, Decimal{"2.2"}}, sink);
 }
 
 UTEST(OpenapiParameters, UserType) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetCookie("test", std::string{"1.1"}));
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetCookie(std::string_view{"test"}, std::string{"1.1"}));
 
-    using Decimal = decimal64::Decimal<10>;
-    co::WriteParameter<co::TrivialParameter<co::In::kCookie, kName, std::string, Decimal>>(Decimal{"1.1"}, sink);
+  using Decimal = decimal64::Decimal<10>;
+  co::WriteParameter<
+      co::TrivialParameter<co::In::kCookie, kTest, std::string, Decimal>>(
+      Decimal{"1.1"}, sink);
 }
 
 UTEST(OpenapiParameters, TypeBoolean) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetCookie("test", std::string{"true"}));
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetCookie(std::string_view{"test"}, std::string{"true"}));
 
-    bool bool_var = true;
-    co::WriteParameter<co::TrivialParameter<co::In::kCookie, kName, bool>>(bool_var, sink);
+  bool bool_var = true;
+  co::WriteParameter<co::TrivialParameter<co::In::kCookie, kTest, bool>>(
+      bool_var, sink);
 }
 
 UTEST(OpenapiParameters, TypeDouble) {
-    static constexpr co::Name kName{"test"};
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetCookie(std::string_view{"test"}, std::string{"2.1"}));
 
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetCookie("test", std::string{"2.1"}));
-
-    double double_var = 2.1;
-    co::WriteParameter<co::TrivialParameter<co::In::kCookie, kName, double>>(double_var, sink);
+  double double_var = 2.1;
+  co::WriteParameter<co::TrivialParameter<co::In::kCookie, kTest, double>>(
+      double_var, sink);
 }
 
 UTEST(OpenapiParameters, TypeInt) {
-    static constexpr co::Name kName{"test"};
-
-    ParameterSinkMock sink;
-    EXPECT_CALL(sink, SetCookie("test", std::string{"1"}));
-    int int_var = 1;
-    co::WriteParameter<co::TrivialParameter<co::In::kCookie, kName, int>>(int_var, sink);
+  ParameterSinkMock sink;
+  EXPECT_CALL(sink, SetCookie(std::string_view{"test"}, std::string{"1"}));
+  int int_var = 1;
+  co::WriteParameter<co::TrivialParameter<co::In::kCookie, kTest, int>>(int_var,
+                                                                        sink);
 }
 
+static constexpr co::Name kName{
+    "name",
+};
+
+static constexpr co::Name kVar1{
+    "var1",
+};
+static constexpr co::Name kVar2{
+    "var2",
+};
+
 UTEST(OpenapiParameters, SinkHttpClient) {
-    auto http_client_ptr = utest::CreateHttpClient();
-    auto request = http_client_ptr->CreateRequest();
-    bool called = false;
-    utest::HttpServerMock http_server([&called](const utest::HttpServerMock::HttpRequest& request) {
+  auto http_client_ptr = utest::CreateHttpClient();
+  auto request = http_client_ptr->CreateRequest();
+  bool called = false;
+  utest::HttpServerMock http_server(
+      [&called](const utest::HttpServerMock::HttpRequest& request) {
         constexpr http::headers::PredefinedHeader kName("name");
         constexpr http::headers::PredefinedHeader kCookie("cookie");
 
         EXPECT_EQ(request.path, "/foo4");
-        EXPECT_EQ(
-            request.query, (std::multimap<std::string, std::string>{{"var1", "foo"}, {"var1", "bar"}, {"var2", "foo1"}})
-        );
+        EXPECT_EQ(request.query,
+                  (std::multimap<std::string, std::string>{
+                      {"var1", "foo"}, {"var1", "bar"}, {"var2", "foo1"}}));
         EXPECT_EQ(request.headers.at(kName), "foo2");
         EXPECT_EQ(request.headers.at(kCookie), "name=foo3");
         called = true;
 
         return utest::HttpServerMock::HttpResponse{};
-    });
-
-    static constexpr co::Name kName{
-        "name",
-    };
+      });
 
-    co::ParameterSinkHttpClient sink(request, http_server.GetBaseUrl() + "/{name}");
+  co::ParameterSinkHttpClient sink(request,
+                                   http_server.GetBaseUrl() + "/{name}");
 
-    static constexpr co::Name kVar1{
-        "var1",
-    };
-    static constexpr co::Name kVar2{
-        "var2",
-    };
-    co::WriteParameter<co::ArrayParameter<co::In::kQueryExplode, kVar1, ',', std::string>>(
-        std::vector<std::string>{"foo", "bar"}, sink
-    );
-    co::WriteParameter<co::TrivialParameter<co::In::kQuery, kVar2, std::string>>("foo1", sink);
+  co::WriteParameter<
+      co::ArrayParameter<co::In::kQueryExplode, kVar1, ',', std::string>>(
+      std::vector<std::string>{"foo", "bar"}, sink);
+  co::WriteParameter<co::TrivialParameter<co::In::kQuery, kVar2, std::string>>(
+      "foo1", sink);
 
-    co::WriteParameter<co::TrivialParameter<co::In::kHeader, kName, std::string>>("foo2", sink);
-    co::WriteParameter<co::TrivialParameter<co::In::kCookie, kName, std::string>>("foo3", sink);
-    co::WriteParameter<co::TrivialParameter<co::In::kPath, kName, std::string>>("foo4", sink);
-    sink.Flush();
+  co::WriteParameter<co::TrivialParameter<co::In::kHeader, kName, std::string>>(
+      "foo2", sink);
+  co::WriteParameter<co::TrivialParameter<co::In::kCookie, kName, std::string>>(
+      "foo3", sink);
+  co::WriteParameter<co::TrivialParameter<co::In::kPath, kName, std::string>>(
+      "foo4", sink);
+  sink.Flush();
 
-    auto response = request.perform();
-    EXPECT_TRUE(called);
+  auto response = request.perform();
+  EXPECT_TRUE(called);
 }
 
 UTEST(OpenapiParameters, InvalidPathVariable) {
-    ParameterSinkMock sink;
-    static constexpr co::Name kName{"test"};
-
-    EXPECT_THROW(
-        (co::WriteParameter<co::TrivialParameter<co::In::kPath, kName, std::string, std::string>>("foo?bar", sink)),
-        std::runtime_error
-    );
-
-    EXPECT_THROW(
-        (co::WriteParameter<co::TrivialParameter<co::In::kPath, kName, std::string, std::string>>("foo/bar", sink)),
-        std::runtime_error
-    );
+  ParameterSinkMock sink;
+
+  EXPECT_THROW(
+      (co::WriteParameter<
+          co::TrivialParameter<co::In::kPath, kTest, std::string, std::string>>(
+          "foo?bar", sink)),
+      std::runtime_error);
+
+  EXPECT_THROW(
+      (co::WriteParameter<
+          co::TrivialParameter<co::In::kPath, kTest, std::string, std::string>>(
+          "foo/bar", sink)),
+      std::runtime_error);
 }
 
 USERVER_NAMESPACE_END