treewide: reorganize unit tests

Like other C++ projects, unit tests normally are in a separate repo and
respect the folder structure of the file under test.

This commit deleted all "ut" folder and move tests to a "test" folder.
The test folder also has similar structure as the main folder.

This commit also made neccessary include changes to make codes compile.
Unused tests are untouched.

Tested: unit test passed.

Reference:
[1] https://github.com/grpc/grpc/tree/master/test
[2] https://github.com/boostorg/core/tree/414dfb466878af427d33b36e6ccf84d21c0e081b/test
[3] Many other OpenBMC repos: https://github.com/openbmc/entity-manager/tree/master/test
[4] https://stackoverflow.com/questions/2360734/whats-a-good-directory-structure-for-larger-c-projects-using-makefile

Signed-off-by: Nan Zhou <nanzhoumails@gmail.com>
Change-Id: I4521c7ef5fa03c47cca5c146d322bbb51365ee96

2 files changed, 0 insertions, 352 deletions

diff --git a/http/ut/router_test.cpp b/http/ut/router_test.cpp
deleted file mode 100644
index 9b5d9bec98..0000000000
--- a/http/ut/router_test.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "async_resp.hpp" // IWYU pragma: keep
-#include "http_request.hpp"
-#include "routing.hpp"
-#include "utility.hpp"
-
-#include <boost/beast/http/message.hpp> // IWYU pragma: keep
-#include <boost/beast/http/verb.hpp>
-
-#include <memory>
-#include <string>
-#include <string_view>
-#include <system_error>
-
-#include <gtest/gtest.h> // IWYU pragma: keep
-
-// IWYU pragma: no_include <boost/beast/http/impl/message.hpp>
-// IWYU pragma: no_include "gtest/gtest_pred_impl.h"
-// IWYU pragma: no_include <boost/intrusive/detail/list_iterator.hpp>
-// IWYU pragma: no_include <gtest/gtest-message.h>
-// IWYU pragma: no_include <gtest/gtest-test-part.h>
-// IWYU pragma: no_forward_declare bmcweb::AsyncResp
-
-namespace crow
-{
-namespace
-{
-
-using ::crow::black_magic::getParameterTag;
-
-TEST(Router, AllowHeader)
-{
-    // Callback handler that does nothing
-    auto nullCallback = [](const Request&,
-                           const std::shared_ptr<bmcweb::AsyncResp>&) {};
-
-    Router router;
-    std::error_code ec;
-
-    constexpr const std::string_view url = "/foo";
-
-    Request req{{boost::beast::http::verb::get, url, 11}, ec};
-
-    // No route should return no methods.
-    router.validate();
-    EXPECT_EQ(router.findRoute(req).allowHeader, "");
-    EXPECT_EQ(router.findRoute(req).route.rule, nullptr);
-
-    router.newRuleTagged<getParameterTag(url)>(std::string(url))
-        .methods(boost::beast::http::verb::get)(nullCallback);
-    router.validate();
-    EXPECT_EQ(router.findRoute(req).allowHeader, "GET");
-    EXPECT_NE(router.findRoute(req).route.rule, nullptr);
-
-    Request patchReq{{boost::beast::http::verb::patch, url, 11}, ec};
-    EXPECT_EQ(router.findRoute(patchReq).route.rule, nullptr);
-
-    router.newRuleTagged<getParameterTag(url)>(std::string(url))
-        .methods(boost::beast::http::verb::patch)(nullCallback);
-    router.validate();
-    EXPECT_EQ(router.findRoute(req).allowHeader, "GET, PATCH");
-    EXPECT_NE(router.findRoute(req).route.rule, nullptr);
-    EXPECT_NE(router.findRoute(patchReq).route.rule, nullptr);
-}
-
-TEST(Router, 404)
-{
-    bool notFoundCalled = false;
-    // Callback handler that does nothing
-    auto nullCallback =
-        [&notFoundCalled](const Request&,
-                          const std::shared_ptr<bmcweb::AsyncResp>&) {
-        notFoundCalled = true;
-    };
-
-    Router router;
-    std::error_code ec;
-
-    constexpr const std::string_view url = "/foo/bar";
-
-    Request req{{boost::beast::http::verb::get, url, 11}, ec};
-
-    router.newRuleTagged<getParameterTag(url)>("/foo/<path>")
-        .notFound()(nullCallback);
-    router.validate();
-    {
-        std::shared_ptr<bmcweb::AsyncResp> asyncResp =
-            std::make_shared<bmcweb::AsyncResp>();
-
-        router.handle(req, asyncResp);
-    }
-    EXPECT_TRUE(notFoundCalled);
-}
-
-TEST(Router, 405)
-{
-    // Callback handler that does nothing
-    auto nullCallback = [](const Request&,
-                           const std::shared_ptr<bmcweb::AsyncResp>&) {};
-    bool called = false;
-    auto notAllowedCallback =
-        [&called](const Request&, const std::shared_ptr<bmcweb::AsyncResp>&) {
-        called = true;
-    };
-
-    Router router;
-    std::error_code ec;
-
-    constexpr const std::string_view url = "/foo/bar";
-
-    Request req{{boost::beast::http::verb::patch, url, 11}, ec};
-
-    router.newRuleTagged<getParameterTag(url)>(std::string(url))
-        .methods(boost::beast::http::verb::get)(nullCallback);
-    router.newRuleTagged<getParameterTag(url)>("/foo/<path>")
-        .methodNotAllowed()(notAllowedCallback);
-    router.validate();
-    {
-        std::shared_ptr<bmcweb::AsyncResp> asyncResp =
-            std::make_shared<bmcweb::AsyncResp>();
-
-        router.handle(req, asyncResp);
-    }
-    EXPECT_TRUE(called);
-}
-} // namespace
-} // namespace crow
diff --git a/http/ut/utility_test.cpp b/http/ut/utility_test.cpp
deleted file mode 100644
index 8eef93f4a3..0000000000
--- a/http/ut/utility_test.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-#include "bmcweb_config.h"
-
-#include "utility.hpp"
-
-#include <boost/url/error.hpp>
-#include <boost/url/url.hpp>
-#include <boost/url/url_view.hpp>
-#include <nlohmann/json.hpp>
-
-#include <cstdint>
-#include <ctime>
-#include <functional>
-#include <limits>
-#include <string>
-#include <string_view>
-
-#include <gtest/gtest.h> // IWYU pragma: keep
-// IWYU pragma: no_include <gtest/gtest-message.h>
-// IWYU pragma: no_include <gtest/gtest-test-part.h>
-// IWYU pragma: no_include "gtest/gtest_pred_impl.h"
-
-namespace crow::utility
-{
-namespace
-{
-
-using ::crow::black_magic::getParameterTag;
-
-TEST(Utility, Base64DecodeAuthString)
-{
-    std::string authString("dXNlcm40bWU6cGFzc3cwcmQ=");
-    std::string result;
-    EXPECT_TRUE(base64Decode(authString, result));
-    EXPECT_EQ(result, "usern4me:passw0rd");
-}
-
-TEST(Utility, Base64DecodeNonAscii)
-{
-    std::string junkString("\xff\xee\xdd\xcc\x01\x11\x22\x33");
-    std::string result;
-    EXPECT_FALSE(base64Decode(junkString, result));
-}
-
-TEST(Utility, Base64EncodeString)
-{
-    using namespace std::string_literals;
-    std::string encoded;
-
-    encoded = base64encode("");
-    EXPECT_EQ(encoded, "");
-
-    encoded = base64encode("f");
-    EXPECT_EQ(encoded, "Zg==");
-
-    encoded = base64encode("f0");
-    EXPECT_EQ(encoded, "ZjA=");
-
-    encoded = base64encode("f0\0"s);
-    EXPECT_EQ(encoded, "ZjAA");
-
-    encoded = base64encode("f0\0 "s);
-    EXPECT_EQ(encoded, "ZjAAIA==");
-
-    encoded = base64encode("f0\0 B"s);
-    EXPECT_EQ(encoded, "ZjAAIEI=");
-
-    encoded = base64encode("f0\0 Ba"s);
-    EXPECT_EQ(encoded, "ZjAAIEJh");
-
-    encoded = base64encode("f0\0 Bar"s);
-    EXPECT_EQ(encoded, "ZjAAIEJhcg==");
-}
-
-TEST(Utility, Base64EncodeDecodeString)
-{
-    using namespace std::string_literals;
-    std::string data("Data fr\0m 90 reading a \nFile"s);
-    std::string encoded = base64encode(data);
-    std::string decoded;
-    EXPECT_TRUE(base64Decode(encoded, decoded));
-    EXPECT_EQ(data, decoded);
-}
-
-TEST(Utility, UrlFromPieces)
-{
-    boost::urls::url url = urlFromPieces("redfish", "v1", "foo");
-    EXPECT_EQ(std::string_view(url.data(), url.size()), "/redfish/v1/foo");
-
-    url = urlFromPieces("/", "badString");
-    EXPECT_EQ(std::string_view(url.data(), url.size()), "/%2f/badString");
-
-    url = urlFromPieces("bad?tring");
-    EXPECT_EQ(std::string_view(url.data(), url.size()), "/bad%3ftring");
-
-    url = urlFromPieces("/", "bad&tring");
-    EXPECT_EQ(std::string_view(url.data(), url.size()), "/%2f/bad&tring");
-}
-
-TEST(Utility, readUrlSegments)
-{
-    boost::urls::result<boost::urls::url_view> parsed =
-        boost::urls::parse_relative_ref("/redfish/v1/Chassis#/Fans/0/Reading");
-
-    EXPECT_TRUE(readUrlSegments(*parsed, "redfish", "v1", "Chassis"));
-
-    EXPECT_FALSE(readUrlSegments(*parsed, "FOOBAR", "v1", "Chassis"));
-
-    EXPECT_FALSE(readUrlSegments(*parsed, "redfish", "v1"));
-
-    EXPECT_FALSE(
-        readUrlSegments(*parsed, "redfish", "v1", "Chassis", "FOOBAR"));
-
-    std::string out1;
-    std::string out2;
-    std::string out3;
-    EXPECT_TRUE(readUrlSegments(*parsed, "redfish", "v1", std::ref(out1)));
-    EXPECT_EQ(out1, "Chassis");
-
-    out1 = out2 = out3 = "";
-    EXPECT_TRUE(readUrlSegments(*parsed, std::ref(out1), std::ref(out2),
-                                std::ref(out3)));
-    EXPECT_EQ(out1, "redfish");
-    EXPECT_EQ(out2, "v1");
-    EXPECT_EQ(out3, "Chassis");
-
-    out1 = out2 = out3 = "";
-    EXPECT_TRUE(readUrlSegments(*parsed, "redfish", std::ref(out1), "Chassis"));
-    EXPECT_EQ(out1, "v1");
-
-    out1 = out2 = out3 = "";
-    EXPECT_TRUE(readUrlSegments(*parsed, std::ref(out1), "v1", std::ref(out2)));
-    EXPECT_EQ(out1, "redfish");
-    EXPECT_EQ(out2, "Chassis");
-
-    EXPECT_FALSE(readUrlSegments(*parsed, "too", "short"));
-
-    EXPECT_FALSE(readUrlSegments(*parsed, "too", "long", "too", "long"));
-
-    EXPECT_FALSE(
-        readUrlSegments(*parsed, std::ref(out1), "v2", std::ref(out2)));
-
-    EXPECT_FALSE(readUrlSegments(*parsed, "redfish", std::ref(out1),
-                                 std::ref(out2), std::ref(out3)));
-
-    parsed = boost::urls::parse_relative_ref("/absolute/url");
-    EXPECT_TRUE(readUrlSegments(*parsed, "absolute", "url"));
-
-    parsed = boost::urls::parse_relative_ref("not/absolute/url");
-    EXPECT_FALSE(readUrlSegments(*parsed, "not", "absolute", "url"));
-
-    parsed = boost::urls::parse_relative_ref("/excellent/path");
-
-    EXPECT_TRUE(readUrlSegments(*parsed, "excellent", "path", OrMorePaths()));
-    EXPECT_TRUE(readUrlSegments(*parsed, "excellent", OrMorePaths()));
-    EXPECT_TRUE(readUrlSegments(*parsed, OrMorePaths()));
-}
-
-TEST(Utility, ValidateAndSplitUrlPositive)
-{
-    std::string host;
-    std::string urlProto;
-    uint16_t port = 0;
-    std::string path;
-    ASSERT_TRUE(validateAndSplitUrl("https://foo.com:18080/bar", urlProto, host,
-                                    port, path));
-    EXPECT_EQ(host, "foo.com");
-    EXPECT_EQ(urlProto, "https");
-    EXPECT_EQ(port, 18080);
-
-    EXPECT_EQ(path, "/bar");
-
-    // query string
-    ASSERT_TRUE(validateAndSplitUrl("https://foo.com:18080/bar?foobar=1",
-                                    urlProto, host, port, path));
-    EXPECT_EQ(path, "/bar?foobar=1");
-
-    // fragment
-    ASSERT_TRUE(validateAndSplitUrl("https://foo.com:18080/bar#frag", urlProto,
-                                    host, port, path));
-    EXPECT_EQ(path, "/bar#frag");
-
-    // Missing port
-    ASSERT_TRUE(
-        validateAndSplitUrl("https://foo.com/bar", urlProto, host, port, path));
-    EXPECT_EQ(port, 443);
-
-    // Missing path defaults to "/"
-    ASSERT_TRUE(
-        validateAndSplitUrl("https://foo.com/", urlProto, host, port, path));
-    EXPECT_EQ(path, "/");
-
-    // If http push eventing is allowed, allow http and pick a default port of
-    // 80, if it's not, parse should fail.
-    ASSERT_EQ(
-        validateAndSplitUrl("http://foo.com/bar", urlProto, host, port, path),
-        bmcwebInsecureEnableHttpPushStyleEventing);
-    if constexpr (bmcwebInsecureEnableHttpPushStyleEventing)
-    {
-        EXPECT_EQ(port, 80);
-    }
-}
-
-TEST(Router, ParameterTagging)
-{
-    EXPECT_EQ(6 * 6 + 6 * 3 + 2, getParameterTag("<uint><double><int>"));
-    EXPECT_EQ(1, getParameterTag("<int>"));
-    EXPECT_EQ(2, getParameterTag("<uint>"));
-    EXPECT_EQ(3, getParameterTag("<float>"));
-    EXPECT_EQ(3, getParameterTag("<double>"));
-    EXPECT_EQ(4, getParameterTag("<str>"));
-    EXPECT_EQ(4, getParameterTag("<string>"));
-    EXPECT_EQ(5, getParameterTag("<path>"));
-    EXPECT_EQ(6 * 6 + 6 + 1, getParameterTag("<int><int><int>"));
-    EXPECT_EQ(6 * 6 + 6 + 2, getParameterTag("<uint><int><int>"));
-    EXPECT_EQ(6 * 6 + 6 * 3 + 2, getParameterTag("<uint><double><int>"));
-}
-
-TEST(URL, JsonEncoding)
-{
-    std::string urlString = "/foo";
-    EXPECT_EQ(nlohmann::json(boost::urls::url(urlString)), urlString);
-    EXPECT_EQ(nlohmann::json(boost::urls::url_view(urlString)), urlString);
-}
-
-} // namespace
-} // namespace crow::utility