Refactor unit tests (#201)

Author: mingxwa

tests/proxy_creation_tests.cpp

@@ -12,7 +12,7 @@
 #pragma warning(pop)
 #endif  // defined(_MSC_VER) && !defined(__clang__)
 
-namespace {
+namespace proxy_dispatch_tests_details {
 
 struct CommaTester {
 public:
@@ -35,7 +35,9 @@ struct PtrToMemTester {
 
 PRO_DEF_FREE_AS_MEM_DISPATCH(FreeMemToString, std::to_string, ToString);
 
-}  // namespace
+}  // namespace proxy_dispatch_tests_details
+
+namespace details = proxy_dispatch_tests_details;
 
 TEST(ProxyDispatchTests, TestOpPlus) {
   struct TestFacade : pro::facade_builder::add_convention<pro::operator_dispatch<"+">, int(), int(int val)>::build {};
@@ -297,7 +299,7 @@ TEST(ProxyDispatchTests, TestOpRightShiftAssignment) {
 
 TEST(ProxyDispatchTests, TestOpComma) {
   struct TestFacade : pro::facade_builder::add_convention<pro::operator_dispatch<",">, int(int val)>::build {};
-  CommaTester v{3};
+  details::CommaTester v{3};
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ((*p, 6), 9);
 }
@@ -572,14 +574,14 @@ TEST(ProxyDispatchTests, TestRhsOpRightShiftAssignment) {
 
 TEST(ProxyDispatchTests, TestRhsOpComma) {
   struct TestFacade : pro::facade_builder::add_convention<pro::operator_dispatch<",", true>, int(int val)>::build {};
-  CommaTester v{3};
+  details::CommaTester v{3};
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ((7, *p), 21);
 }
 
 TEST(ProxyDispatchTests, TestRhsOpPtrToMem) {
   struct TestFacade : pro::facade_builder::add_convention<pro::operator_dispatch<"->*", true>, int(int val)>::build {};
-  PtrToMemTester v{3};
+  details::PtrToMemTester v{3};
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ(2->**p, 6);
 }
@@ -618,7 +620,7 @@ TEST(ProxyDispatchTests, TestImplciitConversion) {
 }
 
 TEST(ProxyDispatchTests, TestFreeAsMemDispatch) {
-  struct TestFacade : pro::facade_builder::add_convention<FreeMemToString, std::string() const>::build {};
+  struct TestFacade : pro::facade_builder::add_convention<details::FreeMemToString, std::string() const>::build {};
   int v = 123;
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ(p->ToString(), "123");

tests/proxy_dispatch_tests.cpp

@@ -11,9 +11,7 @@
 #include <vector>
 #include "proxy.h"
 
-namespace {
-
-namespace spec {
+namespace proxy_integration_tests_details {
 
 PRO_DEF_MEM_DISPATCH(MemDraw, Draw);
 PRO_DEF_MEM_DISPATCH(MemArea, Area);
@@ -29,8 +27,6 @@ struct Logger : pro::facade_builder
     ::add_convention<MemLog, void(const char*), void(const char*, const std::exception&)>
     ::build {};
 
-}  // namespace spec
-
 class Rectangle {
  public:
   explicit Rectangle(double width, double height) : width_(width), height_(height) {}
@@ -61,7 +57,7 @@ class Point {
   constexpr double Area() const noexcept { return 0; }
 };
 
-std::string PrintDrawableToString(pro::proxy<spec::Drawable> p) {
+std::string PrintDrawableToString(pro::proxy<Drawable> p) {
   std::stringstream result;
   result << std::fixed << std::setprecision(5) << "shape = ";
   p->Draw(result);
@@ -92,19 +88,19 @@ std::vector<std::string> ParseCommand(const std::string& s) {
   return result;
 }
 
-pro::proxy<spec::Drawable> MakeDrawableFromCommand(const std::string& s) {
+pro::proxy<Drawable> MakeDrawableFromCommand(const std::string& s) {
   std::vector<std::string> parsed = ParseCommand(s);
   if (!parsed.empty()) {
     if (parsed[0u] == "Rectangle") {
       if (parsed.size() == 3u) {
         static std::pmr::unsynchronized_pool_resource rectangle_memory_pool;
         std::pmr::polymorphic_allocator<> alloc{&rectangle_memory_pool};
-        return pro::allocate_proxy<spec::Drawable, Rectangle>(alloc, std::stod(parsed[1u]), std::stod(parsed[2u]));
+        return pro::allocate_proxy<Drawable, Rectangle>(alloc, std::stod(parsed[1u]), std::stod(parsed[2u]));
       }
     } else if (parsed[0u] == "Circle") {
       if (parsed.size() == 2u) {
         Circle circle{std::stod(parsed[1u])};
-        return pro::make_proxy<spec::Drawable>(circle);
+        return pro::make_proxy<Drawable>(circle);
       }
     } else if (parsed[0u] == "Point") {
       if (parsed.size() == 1u) {
@@ -132,31 +128,33 @@ class StreamLogger {
   std::ostream* out_;
 };
 
-}  // namespace
+}  // namespace proxy_integration_tests_details
+
+namespace details = proxy_integration_tests_details;
 
 TEST(ProxyIntegrationTests, TestDrawable) {
-  pro::proxy<spec::Drawable> p = MakeDrawableFromCommand("Rectangle 2 3");
-  std::string s = PrintDrawableToString(std::move(p));
+  pro::proxy<details::Drawable> p = details::MakeDrawableFromCommand("Rectangle 2 3");
+  std::string s = details::PrintDrawableToString(std::move(p));
   ASSERT_EQ(s, "shape = {Rectangle: width = 2.00000, height = 3.00000}, area = 6.00000");
 
-  p = MakeDrawableFromCommand("Circle 1");
-  s = PrintDrawableToString(std::move(p));
+  p = details::MakeDrawableFromCommand("Circle 1");
+  s = details::PrintDrawableToString(std::move(p));
   ASSERT_EQ(s, "shape = {Circle: radius = 1.00000}, area = 3.14159");
 
-  p = MakeDrawableFromCommand("Point");
-  s = PrintDrawableToString(std::move(p));
+  p = details::MakeDrawableFromCommand("Point");
+  s = details::PrintDrawableToString(std::move(p));
   ASSERT_EQ(s, "shape = {Point}, area = 0.00000");
 
   try {
-    p = MakeDrawableFromCommand("Triangle 2 3");
+    p = details::MakeDrawableFromCommand("Triangle 2 3");
   } catch (const std::runtime_error& e) {
     ASSERT_STREQ(e.what(), "Invalid command");
   }
 }
 
 TEST(ProxyIntegrationTests, TestLogger) {
   std::ostringstream out;
-  auto logger = pro::make_proxy<spec::Logger, StreamLogger>(out);
+  auto logger = pro::make_proxy<details::Logger, details::StreamLogger>(out);
   logger->Log("hello");
   try {
     throw std::runtime_error{"runtime error!"};

tests/proxy_integration_tests.cpp

@@ -21,9 +21,7 @@
 #endif  // defined(_MSC_VER) && !defined(__clang__)
 #include "utils.h"
 
-namespace {
-
-namespace spec {
+namespace proxy_invocation_tests_details {
 
 template <class... Os>
 struct MovableCallable : pro::facade_builder
@@ -113,8 +111,6 @@ struct SharedStringable : pro::facade_builder
     ::add_direct_convention<FreeGetWeak<SharedStringable>, pro::proxy<Weak<SharedStringable>>() const&>
     ::build {};
 
-}  // namespace spec
-
 template <class F, bool NE, class... Args>
 concept CallableFacade =
   requires(pro::proxy<F> p, Args... args) {
@@ -123,16 +119,18 @@ concept CallableFacade =
 };
 
 // Static assertions for facade Callable
-static_assert(!CallableFacade<spec::Callable<int(double)>, false, std::nullptr_t>);  // Wrong arguments
-static_assert(CallableFacade<spec::Callable<int(double)>, false, float>);  // Invoking without specifying a dispatch
-static_assert(CallableFacade<spec::Callable<int(double), void(int) noexcept>, true, int>);  // Invoking noexcept overloads
-static_assert(CallableFacade<spec::Callable<int(double), void(int) noexcept>, false, double>);  // Invoking overloads that may throw
+static_assert(!CallableFacade<Callable<int(double)>, false, std::nullptr_t>);  // Wrong arguments
+static_assert(CallableFacade<Callable<int(double)>, false, float>);  // Invoking without specifying a dispatch
+static_assert(CallableFacade<Callable<int(double), void(int) noexcept>, true, int>);  // Invoking noexcept overloads
+static_assert(CallableFacade<Callable<int(double), void(int) noexcept>, false, double>);  // Invoking overloads that may throw
 
 template <class... Args>
 std::vector<std::type_index> GetTypeIndices()
     { return {std::type_index{typeid(Args)}...}; }
 
-}  // namespace
+}  // namespace proxy_invocation_tests_details
+
+namespace details = proxy_invocation_tests_details;
 
 TEST(ProxyInvocationTests, TestArgumentForwarding) {
   std::string arg1 = "My string";
@@ -146,7 +144,7 @@ TEST(ProxyInvocationTests, TestArgumentForwarding) {
     arg2_received = std::move(v);
     return expected_result;
   };
-  pro::proxy<spec::Callable<int(std::string, std::vector<int>)>> p = &f;
+  pro::proxy<details::Callable<int(std::string, std::vector<int>)>> p = &f;
   int result = (*p)(arg1, std::move(arg2));
   ASSERT_TRUE(p.has_value());
   ASSERT_EQ(arg1_received, arg1);
@@ -159,7 +157,7 @@ TEST(ProxyInvocationTests, TestThrow) {
   const char* expected_error_message = "My exception";
   auto f = [&] { throw std::runtime_error{ expected_error_message }; };
   bool exception_thrown = false;
-  pro::proxy<spec::Callable<void()>> p = &f;
+  pro::proxy<details::Callable<void()>> p = &f;
   try {
     (*p)();
   } catch (const std::runtime_error& e) {
@@ -172,7 +170,7 @@ TEST(ProxyInvocationTests, TestThrow) {
 
 TEST(ProxyInvocationTests, TestMultipleDispatches_Unique) {
   std::list<int> l = { 1, 2, 3 };
-  pro::proxy<spec::Iterable<int>> p = &l;
+  pro::proxy<details::Iterable<int>> p = &l;
   ASSERT_EQ(Size(*p), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
@@ -182,12 +180,12 @@ TEST(ProxyInvocationTests, TestMultipleDispatches_Unique) {
 
 TEST(ProxyInvocationTests, TestMultipleDispatches_Duplicated) {
   struct DuplicatedIterable : pro::facade_builder
-      ::add_convention<spec::FreeForEach, void(std::function<void(int&)>)>
-      ::add_convention<spec::FreeSize, std::size_t()>
-      ::add_convention<spec::FreeForEach, void(std::function<void(int&)>)>
+      ::add_convention<details::FreeForEach, void(std::function<void(int&)>)>
+      ::add_convention<details::FreeSize, std::size_t()>
+      ::add_convention<details::FreeForEach, void(std::function<void(int&)>)>
       ::build {};
   static_assert(sizeof(pro::details::facade_traits<DuplicatedIterable>::meta) ==
-      sizeof(pro::details::facade_traits<spec::Iterable<int>>::meta));
+      sizeof(pro::details::facade_traits<details::Iterable<int>>::meta));
   std::list<int> l = { 1, 2, 3 };
   pro::proxy<DuplicatedIterable> p = &l;
   ASSERT_EQ(Size(*p), 3);
@@ -199,7 +197,7 @@ TEST(ProxyInvocationTests, TestMultipleDispatches_Duplicated) {
 
 TEST(ProxyInvocationTests, TestRecursiveDefinition) {
   std::list<int> l = { 1, 2, 3 };
-  pro::proxy<spec::Container<int>> p = &l;
+  pro::proxy<details::Container<int>> p = &l;
   ASSERT_EQ(Size(*p), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
@@ -218,45 +216,45 @@ TEST(ProxyInvocationTests, TestOverloadResolution) {
       ::build {};
   std::vector<std::type_index> side_effect;
   auto p = pro::make_proxy<OverloadedCallable>([&](auto&&... args)
-      { side_effect = GetTypeIndices<std::decay_t<decltype(args)>...>(); });
+      { side_effect = details::GetTypeIndices<std::decay_t<decltype(args)>...>(); });
   (*p)(123);
-  ASSERT_EQ(side_effect, GetTypeIndices<int>());
+  ASSERT_EQ(side_effect, details::GetTypeIndices<int>());
   (*p)(1.23);
-  ASSERT_EQ(side_effect, GetTypeIndices<double>());
+  ASSERT_EQ(side_effect, details::GetTypeIndices<double>());
   char foo[2];
   (*p)(foo);
-  ASSERT_EQ(side_effect, GetTypeIndices<char*>());
+  ASSERT_EQ(side_effect, details::GetTypeIndices<char*>());
   (*p)("lalala");
-  ASSERT_EQ(side_effect, GetTypeIndices<const char*>());
+  ASSERT_EQ(side_effect, details::GetTypeIndices<const char*>());
   (*p)("lalala", 0);
-  ASSERT_EQ(side_effect, (GetTypeIndices<std::string, int>()));
+  ASSERT_EQ(side_effect, (details::GetTypeIndices<std::string, int>()));
   ASSERT_FALSE((std::is_invocable_v<decltype(*p), std::vector<int>>));
 }
 
 TEST(ProxyInvocationTests, TestNoexcept) {
   std::vector<std::type_index> side_effect;
-  auto p = pro::make_proxy<spec::Callable<void(int) noexcept, void(double)>>([&](auto&&... args) noexcept
-    { side_effect = GetTypeIndices<std::decay_t<decltype(args)>...>(); });
+  auto p = pro::make_proxy<details::Callable<void(int) noexcept, void(double)>>([&](auto&&... args) noexcept
+    { side_effect = details::GetTypeIndices<std::decay_t<decltype(args)>...>(); });
   static_assert(noexcept((*p)(123)));
   (*p)(123);
-  ASSERT_EQ(side_effect, GetTypeIndices<int>());
+  ASSERT_EQ(side_effect, details::GetTypeIndices<int>());
   static_assert(!noexcept((*p)(1.23)));
   (*p)(1.23);
-  ASSERT_EQ(side_effect, GetTypeIndices<double>());
+  ASSERT_EQ(side_effect, details::GetTypeIndices<double>());
   ASSERT_FALSE((std::is_invocable_v<decltype(*p), char*>));
 }
 
 TEST(ProxyInvocationTests, TestFunctionPointer) {
-  struct TestFacade : spec::Callable<std::vector<std::type_index>()> {};
-  pro::proxy<TestFacade> p{ &GetTypeIndices<int, double> };
+  struct TestFacade : details::Callable<std::vector<std::type_index>()> {};
+  pro::proxy<TestFacade> p{ &details::GetTypeIndices<int, double> };
   auto ret = (*p)();
-  ASSERT_EQ(ret, (GetTypeIndices<int, double>()));
+  ASSERT_EQ(ret, (details::GetTypeIndices<int, double>()));
 }
 
 TEST(ProxyInvocationTests, TestMemberDispatchDefault) {
   std::vector<std::string> container1{ "hello", "world", "!"};
   std::list<std::string> container2{ "hello", "world" };
-  pro::proxy<spec::ResourceDictionary> p = &container1;
+  pro::proxy<details::ResourceDictionary> p = &container1;
   ASSERT_EQ(p->at(0), "hello");
   p = &container2;
   {
@@ -274,13 +272,13 @@ TEST(ProxyInvocationTests, TestMemberDispatchDefault) {
 TEST(ProxyInvocationTests, TestFreeDispatchDefault) {
   {
     int side_effect = 0;
-    auto p = pro::make_proxy<spec::WeakCallable<void()>>([&] { side_effect = 1; });
+    auto p = pro::make_proxy<details::WeakCallable<void()>>([&] { side_effect = 1; });
     (*p)();
     ASSERT_EQ(side_effect, 1);
   }
   {
     bool exception_thrown = false;
-    auto p = pro::make_proxy<spec::WeakCallable<void()>>(123);
+    auto p = pro::make_proxy<details::WeakCallable<void()>>(123);
     try {
       (*p)();
     } catch (const std::runtime_error& e) {
@@ -293,7 +291,7 @@ TEST(ProxyInvocationTests, TestFreeDispatchDefault) {
 
 TEST(ProxyInvocationTests, TestObserverDispatch) {
   int test_val = 123;
-  pro::proxy<spec::SharedStringable> p{std::make_shared<int>(test_val)};
+  pro::proxy<details::SharedStringable> p{std::make_shared<int>(test_val)};
   auto weak = GetWeak(p);
   ASSERT_TRUE(weak.has_value());
   {