fixed warnings, change the approach to assert and the test main

Author: dietmarkuehl

CMakePresets.json

@@ -13,7 +13,7 @@
           "value": "${sourceDir}/stagedir"
         },
         "CMAKE_CXX_EXTENSIONS": false,
-        "CMAKE_CXX_STANDARD": "26",
+        "CMAKE_CXX_STANDARD": "23",
         "CMAKE_CXX_STANDARD_REQUIRED": true,
         "CMAKE_EXPORT_COMPILE_COMMANDS": true
       }

LICENSE.txt

@@ -174,7 +174,7 @@ The Beman Project is under the Apache License v2.0 with LLVM Exceptions:
       on Your own behalf and on Your sole responsibility, not on behalf
       of any other Contributor, and only if You agree to indemnify,
       defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
+      incurred by, or claims ASSERTed against, such Contributor by reason
       of your accepting any such warranty or additional liability.
 
     END OF TERMS AND CONDITIONS

Makefile

@@ -48,7 +48,7 @@ default: test
 
 all: $(SANITIZERS)
 
-run: test # XXX build
+run: test
 	./$(BUILD)/examples/$(EXAMPLE)
 
 release: test
@@ -61,9 +61,8 @@ build:
 	cd $(BUILD); CC=$(CXX) cmake $(SOURCEDIR) $(TOOLCHAIN) $(SYSROOT) -DCMAKE_CXX_COMPILER=$(CXX) -DCMAKE_CXX_FLAGS="$(CXX_FLAGS) $(SAN_FLAGS)"
 	cmake --build $(BUILD)
 
-test: # XXX build
+test:
 	cmake --workflow --preset $(SANITIZER)
-	# XXX cd $(BUILD); $(MAKE) test
 
 ce:
 	@mkdir -p $(BUILD)

bin/update-cmake-headers.py

@@ -25,7 +25,7 @@ def get_headers(dir):
 }
 
 file_set_re = re.compile(" *FILE_SET.*")
-section_re  = re.compile(" *FILE_SET \${TARGET_LIBRARY}_(?P<section>.*)_headers TYPE HEADERS")
+section_re  = re.compile(" *\${TARGET_LIBRARY}_(?P<section>.*)_headers$")
 header_re   = re.compile(" *\${PROJECT_SOURCE_DIR}/include/beman/.*/.*\.hpp")
 
 if len(sys.argv) != 2:
@@ -54,7 +54,7 @@ def get_headers(dir):
                 section_done = True
                 project = "${PROJECT_SOURCE_DIR}"
                 for header in sections[section]:
-                    output.write(f'    {project}/include/{header}.hpp\n')
+                    output.write(f'         {project}/include/{header}.hpp\n')
         else:
             output.write(line)
-            pass
+            pass

include/beman/execution26/detail/as_except_ptr.hpp

@@ -20,7 +20,6 @@ namespace beman::execution26::detail
     {
         if constexpr (::std::same_as<::std::exception_ptr, ::std::decay_t<Error>>)
         {
-            assert(error != ::std::exception_ptr());
             return ::std::forward<Error>(error);
         }
         else if constexpr (::std::same_as<::std::error_code, ::std::decay_t<Error>>)

src/beman/execution26/CMakeLists.txt

@@ -176,10 +176,13 @@ source_group("Header Files\\detail" FILES ${DETAIL_HEADER_FILES})
 
 set_target_properties(${TARGET_LIBRARY} PROPERTIES VERIFY_INTERFACE_HEADER_SETS ON)
 
-target_compile_features(${TARGET_LIBRARY} PUBLIC
-  "$<$<COMPILE_FEATURES:cxx_std_26>:cxx_std_26>"
-  "$<$<NOT:$<COMPILE_FEATURES:cxx_std_26>>:cxx_std_23>"
-)
+#target_compile_features(${TARGET_LIBRARY} PUBLIC
+#  "$<$<COMPILE_FEATURES:cxx_std_26>:cxx_std_26>"
+#  "$<$<NOT:$<COMPILE_FEATURES:cxx_std_26>>:cxx_std_23>"
+#)
+#target_compile_features(${TARGET_LIBRARY} PUBLIC
+#  "$<$<NOT:$<COMPILE_FEATURES:cxx_std_26>>:cxx_std_23>"
+#)
 
 install(
   TARGETS ${TARGET_LIBRARY}

src/beman/execution26/tests/allocator-requirements-general.pass.cpp

@@ -102,7 +102,7 @@ namespace
     };
 }
 
-auto main() -> int
+TEST(allocator_requirements_general)
 {
     static_assert(not test_detail::simple_allocator<non_allocator>);
     static_assert(not test_detail::simple_allocator<no_allocate>);

src/beman/execution26/tests/exec-awaitable.pass.cpp

@@ -115,27 +115,27 @@ namespace
 
         auto a1{test_detail::get_awaiter(awaiter<bool, void>{17}, promise)};
         static_assert(std::same_as<awaiter<bool, void>, decltype(a1)>);
-        assert(a1.value == 17);
+        ASSERT(a1.value == 17);
 
         auto a2{test_detail::get_awaiter(awaiter<bool, bool>{17}, promise)};
         static_assert(std::same_as<awaiter<bool, std::coroutine_handle<>>, decltype(a2)>);
-        assert(a2.value == 19);
+        ASSERT(a2.value == 19);
 
         auto a3{test_detail::get_awaiter(co_awaiter{17}, promise)};
         static_assert(std::same_as<awaiter<bool, bool>, decltype(a3)>);
-        assert(a3.value == 20);
+        ASSERT(a3.value == 20);
 
         auto a4{test_detail::get_awaiter(awaiter<bool, int>{17}, promise)};
         static_assert(std::same_as<awaiter<bool, bool>, decltype(a4)>);
-        assert(a4.value == 24);
+        ASSERT(a4.value == 24);
 
         auto a5{test_detail::get_awaiter(awaiter<bool, long>{17}, promise)};
         static_assert(std::same_as<awaiter<bool, bool>, decltype(a5)>);
-        assert(a5.value == 27);
+        ASSERT(a5.value == 27);
 
         auto a6{test_detail::get_awaiter(mem_co_awaiter{17}, promise)};
         static_assert(std::same_as<awaiter<bool, bool>, decltype(a6)>);
-        assert(a6.value == 22);
+        ASSERT(a6.value == 22);
     }
 
     auto test_is_awaitable() -> void
@@ -201,7 +201,7 @@ namespace
     }
 }
 
-auto main() -> int
+TEST(exec_awaitable)
 {
     test_await_suspend_result();
     test_is_awaiter();
@@ -211,4 +211,4 @@ auto main() -> int
     test_has_as_awaitable();
     test_with_await_transform();
     test_env_promise();
-}
+}

src/beman/execution26/tests/exec-connect.pass.cpp

@@ -153,13 +153,13 @@ namespace
 
         static_assert(noexcept(std::as_const(promise).get_env()));
         static_assert(std::same_as<env, decltype(promise.get_env())>);
-        assert(19 == promise.get_env().value);
+        ASSERT(19 == promise.get_env().value);
 
         static_assert(noexcept(promise.unhandled_stopped()));
         static_assert(std::same_as<std::coroutine_handle<>, decltype(promise.unhandled_stopped())>);
-        assert(set_stopped_called == false);
+        ASSERT(set_stopped_called == false);
         auto handle{promise.unhandled_stopped()};
-        assert(set_stopped_called == true && handle == std::noop_coroutine());
+        ASSERT(set_stopped_called == true && handle == std::noop_coroutine());
 
         static_assert(noexcept(promise.get_return_object()));
         static_assert(std::same_as<test_detail::operation_state_task<receiver>, decltype(promise.get_return_object())>);
@@ -192,11 +192,11 @@ namespace
         static_assert(false == awaiter.await_ready());
         static_assert(noexcept(awaiter.await_suspend(std::noop_coroutine())));
         static_assert(std::same_as<void, decltype(awaiter.await_suspend(std::noop_coroutine()))>);
-        assert(iv == 0);
-        assert(bv == false);
+        ASSERT(iv == 0);
+        ASSERT(bv == false);
         awaiter.await_suspend(std::noop_coroutine());
-        assert(iv == 17);
-        assert(bv == true);
+        ASSERT(iv == 17);
+        ASSERT(bv == true);
 
         static_assert(noexcept(awaiter.await_resume()));
         static_assert(std::same_as<void, decltype(awaiter.await_resume())>);
@@ -254,13 +254,13 @@ namespace
             bool                      bv{};
 
             auto op1{test_detail::connect_awaitable(awaiter{handle, result}, receiver{iv, bv})};
-            assert(handle == std::coroutine_handle<>());
+            ASSERT(handle == std::coroutine_handle<>());
             op1.start();
-            assert(handle != std::coroutine_handle<>());
-            assert(iv == 0 && bv == false);
+            ASSERT(handle != std::coroutine_handle<>());
+            ASSERT(iv == 0 && bv == false);
             result = 42;
             handle.resume();
-            assert(iv == 42 && bv == true);
+            ASSERT(iv == 42 && bv == true);
         }
         {
             ::std::coroutine_handle<> handle{};
@@ -269,13 +269,13 @@ namespace
             bool                      bv{};
 
             auto op1{test_detail::connect_awaitable(awaiter{handle, result}, receiver{iv, bv})};
-            assert(handle == std::coroutine_handle<>());
+            ASSERT(handle == std::coroutine_handle<>());
             op1.start();
-            assert(handle != std::coroutine_handle<>());
-            assert(iv == 0 && bv == false);
+            ASSERT(handle != std::coroutine_handle<>());
+            ASSERT(iv == 0 && bv == false);
             result = 0;
             handle.resume();
-            assert(iv == 0 && bv == true);
+            ASSERT(iv == 0 && bv == true);
         }
 
         {
@@ -284,12 +284,12 @@ namespace
             bool                      bv{};
 
             auto op1{test_detail::connect_awaitable(void_awaiter{handle}, receiver{iv, bv})};
-            assert(handle == std::coroutine_handle<>());
+            ASSERT(handle == std::coroutine_handle<>());
             op1.start();
-            assert(handle != std::coroutine_handle<>());
-            assert(iv == 0 && bv == false);
+            ASSERT(handle != std::coroutine_handle<>());
+            ASSERT(iv == 0 && bv == false);
             handle.resume();
-            assert(iv == 0 && bv == true);
+            ASSERT(iv == 0 && bv == true);
         }
     }
 
@@ -314,16 +314,16 @@ namespace
         std::coroutine_handle<> handle{};
         bool                    result{};
         auto op{test_std::connect(awaiter{handle}, receiver{result})};
-        assert(handle == std::coroutine_handle{});
+        ASSERT(handle == std::coroutine_handle{});
         test_std::start(op);
-        assert(handle != std::coroutine_handle{});
-        assert(result == false);
+        ASSERT(handle != std::coroutine_handle{});
+        ASSERT(result == false);
         handle.resume();
-        assert(result == true);
+        ASSERT(result == true);
     }
 }
 
-auto main() -> int
+TEST(exec_connect)
 {
     static_assert(std::same_as<test_std::connect_t const, decltype(test_std::connect)>);
 
@@ -336,16 +336,16 @@ auto main() -> int
         static_assert(std::same_as<state<kind::plain, receiver>,
             decltype(test_std::connect(sender{43}, receiver(17)))>);
         auto op{test_std::connect(sender{43}, receiver(17))};
-        assert(op.value == 43);
-        assert(op.receiver == receiver(17));
+        ASSERT(op.value == 43);
+        ASSERT(op.receiver == receiver(17));
     }
 
     {
         static_assert(std::same_as<state<kind::plain, receiver>,
             decltype(test_std::connect(rvalue_sender(42), receiver(17)))>);
         auto op{test_std::connect(rvalue_sender(42), receiver(17))};
-        assert(op.value == 42);
-        assert(op.receiver == receiver(17));
+        ASSERT(op.value == 42);
+        ASSERT(op.receiver == receiver(17));
     }
 
     {
@@ -359,13 +359,13 @@ auto main() -> int
         static_assert(std::same_as<state<kind::domain, domain_receiver>,
             decltype(test_std::connect(sender{42}, domain_receiver(17)))>);
         auto op{test_std::connect(sender{42}, domain_receiver(17))};
-        assert(op.value == 42);
-        assert(op.receiver == domain_receiver(17));
+        ASSERT(op.value == 42);
+        ASSERT(op.receiver == domain_receiver(17));
     }
 
     test_connect_awaitable_promise();
     test_operation_state_task();
     test_suspend_complete();
     test_connect_awaitable();
     test_connect_with_awaiter();
-}
+}

src/beman/execution26/tests/exec-continues-on.pass.cpp

@@ -100,7 +100,7 @@ namespace
     }
 }
 
-auto main() -> int
+TEST(exec_continues_on)
 {
     static_assert(std::same_as<test_std::continues_on_t const, decltype(test_std::continues_on)>);
     static_assert(not test_std::scheduler<non_scheduler>);
@@ -114,4 +114,4 @@ auto main() -> int
     test_constraints<true>(scheduler{}, sender{});
 
     test_use(scheduler{}, sender{});
-}
+}