chore: Improve compatability of tests with CMAKE_UNITY_BUILD

.github/workflows/build.yml

@@ -16,7 +16,7 @@ on:
 
 env:
   VCPKG_VERSION: '821100d967e1737d96414a308e3f7cbe0d1abf18'
-  CMAKE_ARGS: '-DCMAKE_BUILD_TYPE=Release -DVCPKG_MANIFEST_INSTALL=off -DASIO_GRPC_ENABLE_PKGCONFIG_FALLBACK=off -DCMAKE_COMPILE_WARNING_AS_ERROR=on -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=on -DTHREADS_PREFER_PTHREAD_FLAG=on'
+  CMAKE_ARGS: '-DCMAKE_BUILD_TYPE=Release -DVCPKG_MANIFEST_INSTALL=off -DASIO_GRPC_ENABLE_PKGCONFIG_FALLBACK=off -DCMAKE_COMPILE_WARNING_AS_ERROR=on -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=on -DTHREADS_PREFER_PTHREAD_FLAG=on -DCMAKE_UNITY_BUILD=on -DUNITY_BUILD_BATCH_SIZE=4'
   CTEST_ARGS: '-T test --output-on-failure --timeout 180 --no-tests=error --parallel 25'
 
 jobs:
@@ -199,7 +199,7 @@ jobs:
       run: ${{ env.VCPKG_ROOT }}/vcpkg install --recurse --clean-after-build --triplet ${{ env.TRIPLET }} --host-triplet ${{ env.TRIPLET }} --x-install-root=${{ runner.workspace }}/vcpkg_installed --overlay-ports=${{ github.workspace }}/deps --overlay-triplets=${{ github.workspace }}/.github/vcpkg
 
     - name: Clang 10 Configure CMake
-      run: cmake --preset default -B ${{ github.workspace }}/build-10 -DCMAKE_CXX_COMPILER=$(which clang++-10) -DCMAKE_UNITY_BUILD=on -DVCPKG_INSTALLED_DIR=${{ runner.workspace }}/vcpkg_installed ${{ env.CMAKE_EXTRA_ARGS }} ${{ env.CMAKE_ARGS }}
+      run: cmake --preset default -B ${{ github.workspace }}/build-10 -DCMAKE_CXX_COMPILER=$(which clang++-10) -DVCPKG_INSTALLED_DIR=${{ runner.workspace }}/vcpkg_installed ${{ env.CMAKE_EXTRA_ARGS }} ${{ env.CMAKE_ARGS }}
 
     - name: Clang 10 Build
       run: cmake --build ${{ github.workspace }}/build-10 --config Release --parallel $(nproc)

CMakeLists.txt

@@ -33,7 +33,7 @@ include("${CMAKE_CURRENT_LIST_DIR}/cmake/AsioGrpcOptionDefaults.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/cmake/AsioGrpcProjectTopLevel.cmake")
 include(GNUInstallDirs)
 
-# more user options
+# user options
 option(ASIO_GRPC_INSTALL "Create the install target" ${ASIO_GRPC_PROJECT_IS_TOP_LEVEL})
 set(ASIO_GRPC_CMAKE_CONFIG_INSTALL_DIR
     "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"

cmake/AsioGrpcCompileOptions.cmake

@@ -47,7 +47,9 @@ target_compile_options(
               /Zc:preprocessor
               /Zc:externConstexpr
               /Zc:lambda
-              /Zc:throwingNew>
+              /Zc:throwingNew
+              $<$<BOOL:${CMAKE_UNITY_BUILD}>:/bigobj>
+              >
               $<$<OR:$<CXX_COMPILER_ID:GNU,AppleClang>,$<STREQUAL:${CMAKE_CXX_COMPILER_FRONTEND_VARIANT},GNU>>:
               -Wall
               -Wextra

doc/CMakeLists.txt

@@ -50,13 +50,8 @@ function(asio_grpc_doxygen)
     set(DOXYGEN_MACRO_EXPANSION "YES")
     set(DOXYGEN_INCLUDE_PATH "${ASIO_GRPC_PROJECT_ROOT}/src" "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}")
     set(DOXYGEN_PREDEFINED
-        "AGRPC_BOOST_ASIO"
-        "AGRPC_GENERATING_DOCUMENTATION"
-        "AGRPC_ASIO_HAS_CO_AWAIT"
-        "AGRPC_ASIO_HAS_CANCELLATION_SLOT"
-        "AGRPC_ASIO_HAS_BIND_ALLOCATOR"
-        "AGRPC_ASIO_HAS_NEW_SPAWN"
-        "AGRPC_ASIO_HAS_IMMEDIATE_EXECUTOR")
+        "AGRPC_BOOST_ASIO" "AGRPC_GENERATING_DOCUMENTATION" "AGRPC_ASIO_HAS_CO_AWAIT"
+        "AGRPC_ASIO_HAS_CANCELLATION_SLOT" "AGRPC_ASIO_HAS_NEW_SPAWN" "AGRPC_ASIO_HAS_IMMEDIATE_EXECUTOR")
     set(DOXYGEN_SKIP_FUNCTION_MACROS "NO")
 
     doxygen_add_docs(asio-grpc-doxygen WORKING_DIRECTORY "${ASIO_GRPC_PROJECT_ROOT}")

src/agrpc/detail/epilogue.hpp

@@ -25,9 +25,8 @@
 
 #undef AGRPC_NAMESPACE_END
 
-// asio_forward.hpp
+// asio_macros.hpp
 #undef AGRPC_ASIO_HAS_CANCELLATION_SLOT
-#undef AGRPC_ASIO_HAS_BIND_ALLOCATOR
 #undef AGRPC_ASIO_HAS_NEW_SPAWN
 #undef AGRPC_ASIO_HAS_IMMEDIATE_EXECUTOR
 

src/agrpc/detail/server_rpc_sender.hpp

@@ -24,6 +24,7 @@
 #include <agrpc/grpc_executor.hpp>
 #include <grpcpp/generic/async_generic_service.h>
 
+#include <agrpc/detail/asio_macros.hpp>
 #include <agrpc/detail/config.hpp>
 
 AGRPC_NAMESPACE_BEGIN()

test/src/CMakeLists.txt

@@ -47,10 +47,11 @@ set(ASIO_GRPC_CPP17_TEST_SOURCE_FILES
 set(ASIO_GRPC_CPP20_TEST_SOURCE_FILES "test_alarm_20.cpp" "test_bind_allocator_20.cpp" "test_grpc_context_20.cpp"
                                       "test_server_rpc_20.cpp")
 
-set_source_files_properties("test_test_17.cpp" "test_execution.cpp" PROPERTIES SKIP_UNITY_BUILD_INCLUSION on)
-set_source_files_properties(
-    "test_client_rpc_17.cpp" "test_server_rpc_17.cpp" "test_server_rpc_20.cpp" "test_unifex_20.cpp" "test_execution.cpp"
-    PROPERTIES COMPILE_OPTIONS "$<$<AND:$<CXX_COMPILER_ID:MSVC>,$<CONFIG:Debug>>:/bigobj>")
+if(NOT CMAKE_UNITY_BUILD)
+    set_source_files_properties(
+        "test_client_rpc_17.cpp" "test_server_rpc_17.cpp" "test_server_rpc_20.cpp" "test_unifex_20.cpp"
+        "test_execution.cpp" PROPERTIES COMPILE_OPTIONS "$<$<AND:$<CXX_COMPILER_ID:MSVC>,$<CONFIG:Debug>>:/bigobj>")
+endif()
 
 asio_grpc_add_test(asio-grpc-test-boost-cpp17 "boost-asio" "17" ${ASIO_GRPC_CPP17_TEST_SOURCE_FILES})
 asio_grpc_add_test(asio-grpc-test-cpp17 "standalone-asio" "17" ${ASIO_GRPC_CPP17_TEST_SOURCE_FILES})

test/src/test_execution.cpp

@@ -207,15 +207,24 @@ TEST_CASE("stdexec GrpcContext.stop() with pending GrpcSender operation")
     CHECK_FALSE(invoked);
 }
 
-inline decltype(stdexec::schedule(std::declval<agrpc::GrpcExecutor>())) request_handler_archetype(test::UnaryServerRPC&,
-                                                                                                  test::msg::Request&);
+decltype(stdexec::schedule(std::declval<agrpc::GrpcExecutor>())) request_handler_archetype(test::UnaryServerRPC&,
+                                                                                           test::msg::Request&);
 
-TEST_CASE_FIXTURE(test::GrpcClientServerTest, "RegisterSenderRPCHandlerSender fulfills unified executor concepts")
+TEST_CASE("stdexec RegisterSenderRPCHandlerSender fulfills unified executor concepts")
 {
     using RegisterSenderRPCHandlerSender = decltype(agrpc::register_sender_rpc_handler<test::UnaryServerRPC>(
-        grpc_context, service, &request_handler_archetype));
+        std::declval<agrpc::GrpcContext&>(), std::declval<test::v1::Test::AsyncService&>(),
+        &request_handler_archetype));
     CHECK(stdexec::sender<RegisterSenderRPCHandlerSender>);
     CHECK(stdexec::sender_to<RegisterSenderRPCHandlerSender, test::FunctionAsReceiver<test::InvocableArchetype>>);
+    CHECK(noexcept(stdexec::connect(std::declval<RegisterSenderRPCHandlerSender>(),
+                                    std::declval<test::ConditionallyNoexceptNoOpReceiver<true>>())));
+    CHECK_FALSE(noexcept(stdexec::connect(std::declval<RegisterSenderRPCHandlerSender>(),
+                                          std::declval<test::ConditionallyNoexceptNoOpReceiver<false>>())));
+    CHECK(noexcept(stdexec::connect(std::declval<RegisterSenderRPCHandlerSender>(),
+                                    std::declval<const test::ConditionallyNoexceptNoOpReceiver<true>&>())));
+    CHECK_FALSE(noexcept(stdexec::connect(std::declval<RegisterSenderRPCHandlerSender>(),
+                                          std::declval<const test::ConditionallyNoexceptNoOpReceiver<false>&>())));
     using OperationState =
         stdexec::connect_result_t<RegisterSenderRPCHandlerSender, test::FunctionAsReceiver<test::InvocableArchetype>>;
     CHECK(std::is_invocable_v<decltype(stdexec::start), OperationState&>);

test/src/test_unifex_20.cpp

@@ -85,29 +85,6 @@ TEST_CASE_FIXTURE(test::ExecutionGrpcContextTest, "unifex cancel agrpc::Alarm.wa
     CHECK_FALSE(state.exception);
 }
 
-inline decltype(unifex::schedule(std::declval<agrpc::GrpcExecutor>())) request_handler_archetype(
-    grpc::ServerContext&, test::msg::Request&, grpc::ServerAsyncResponseWriter<test::msg::Response>&);
-
-TEST_CASE_FIXTURE(test::GrpcClientServerTest, "RegisterSenderRPCHandlerSender fulfills unified executor concepts")
-{
-    using RegisterSenderRPCHandlerSender = decltype(agrpc::register_sender_rpc_handler<test::UnaryServerRPC>(
-        grpc_context, service, &request_handler_archetype));
-    CHECK(unifex::sender<RegisterSenderRPCHandlerSender>);
-    CHECK(unifex::typed_sender<RegisterSenderRPCHandlerSender>);
-    CHECK(unifex::sender_to<RegisterSenderRPCHandlerSender, test::FunctionAsReceiver<test::InvocableArchetype>>);
-    CHECK(unifex::is_nothrow_connectable_v<RegisterSenderRPCHandlerSender,
-                                           test::ConditionallyNoexceptNoOpReceiver<true>>);
-    CHECK_FALSE(unifex::is_nothrow_connectable_v<RegisterSenderRPCHandlerSender,
-                                                 test::ConditionallyNoexceptNoOpReceiver<false>>);
-    CHECK(unifex::is_nothrow_connectable_v<RegisterSenderRPCHandlerSender,
-                                           const test::ConditionallyNoexceptNoOpReceiver<true>&>);
-    CHECK_FALSE(unifex::is_nothrow_connectable_v<RegisterSenderRPCHandlerSender,
-                                                 const test::ConditionallyNoexceptNoOpReceiver<false>&>);
-    using OperationState =
-        unifex::connect_result_t<RegisterSenderRPCHandlerSender, test::FunctionAsReceiver<test::InvocableArchetype>>;
-    CHECK(std::is_invocable_v<decltype(unifex::start), OperationState&>);
-}
-
 #if !UNIFEX_NO_COROUTINES
 TEST_CASE_FIXTURE(test::ExecutionClientRPCTest<test::BidirectionalStreamingClientRPC>,
                   "unifex BidirectionalStreamingClientRPC can be cancelled")

test/utils/utils/precompiled_header.hpp

@@ -15,11 +15,6 @@
 #include "test/v1/test.grpc.pb.h"
 
 #include <doctest/doctest.h>
-#include <google/protobuf/arena.h>
-#include <google/protobuf/extension_set.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/io/coded_stream.h>
 #include <grpcpp/alarm.h>
 #include <grpcpp/generic/async_generic_service.h>
 #include <grpcpp/generic/generic_stub.h>

test/utils/utils/test.cpp

@@ -30,11 +30,11 @@ void set_up_unary_test(MockTest& test)
             });
     EXPECT_CALL(test.stub, PrepareAsyncUnaryRaw)
         .WillOnce(
-            [reader = std::move(mock_reader)]
+            [reader = std::make_shared<decltype(mock_reader)>(std::move(mock_reader))]
             {
                 // GRPC wraps the return value into a unique_ptr with a specialized std::default_delete that does
                 // nothing
-                return reader.get();
+                return reader->get();
             });
 }