Merge pull request #58 from beman-project/fix-warnings

Fix warnings

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
       }

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/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{});
-}
+}

src/beman/execution26/tests/exec-domain-default.pass.cpp

@@ -100,9 +100,9 @@ namespace
         using simple_env_clvalue_type = decltype(Domain::transform_sender(csender, env{}));
         static_assert(std::same_as<simple_sender const&, simple_env_clvalue_type>);
 
-        assert(simple_sender{17} == Domain::transform_sender(simple_sender{17}, env{}));
-        assert(&sender == &Domain::transform_sender(sender, env{}));
-        assert(&csender == &Domain::transform_sender(csender, env{}));
+        ASSERT(simple_sender{17} == Domain::transform_sender(simple_sender{17}, env{}));
+        ASSERT(&sender == &Domain::transform_sender(sender, env{}));
+        ASSERT(&csender == &Domain::transform_sender(csender, env{}));
 
         static_assert(test_std::sender<tagged_sender<true>>);
         static_assert(test_std::sender<tagged_sender<false>>);
@@ -125,22 +125,22 @@ namespace
         {
             using type = decltype(Domain::transform_sender(tagged_sender<true>()));
             static_assert(std::same_as<simple_sender, type>);
-            assert(simple_sender{17} == Domain::transform_sender(tagged_sender<true>()));
+            ASSERT(simple_sender{17} == Domain::transform_sender(tagged_sender<true>()));
         }
         {
             using type = decltype(Domain::transform_sender(tagged_sender<true>(), env{}));
             static_assert(std::same_as<simple_sender, type>);
-            assert(simple_sender{17} == Domain::transform_sender(tagged_sender<true>(), env{}));
+            ASSERT(simple_sender{17} == Domain::transform_sender(tagged_sender<true>(), env{}));
         }
         {
             using type = decltype(Domain::transform_sender(tagged_sender<false>()));
             static_assert(std::same_as<simple_sender, type>);
-            assert(simple_sender{17} == Domain::transform_sender(tagged_sender<false>()));
+            ASSERT(simple_sender{17} == Domain::transform_sender(tagged_sender<false>()));
         }
         {
             using type = decltype(Domain::transform_sender(tagged_sender<false>(), env{}));
             static_assert(std::same_as<simple_sender, type>);
-            assert(simple_sender{17} == Domain::transform_sender(tagged_sender<false>(), env{}));
+            ASSERT(simple_sender{17} == Domain::transform_sender(tagged_sender<false>(), env{}));
         }
         //-dk:TODO test returning a non-sender doesn't work
     }
@@ -155,19 +155,19 @@ namespace
         {
             using type = decltype(Domain::transform_env(simple_sender{}, env{}));
             static_assert(std::same_as<env, type>);
-            assert(env{17} == Domain::transform_env(simple_sender{}, env{17}));
+            ASSERT(env{17} == Domain::transform_env(simple_sender{}, env{17}));
         }
         {
             env e{17};
             using type = decltype(Domain::transform_env(simple_sender{}, e));
             static_assert(std::same_as<env&, type>);
-            assert(&e == &Domain::transform_env(simple_sender{}, e));
+            ASSERT(&e == &Domain::transform_env(simple_sender{}, e));
         }
         {
             env const ce{17};
             using type = decltype(Domain::transform_env(simple_sender{}, ce));
             static_assert(std::same_as<env const&, type>);
-            assert(&ce == &Domain::transform_env(simple_sender{}, ce));
+            ASSERT(&ce == &Domain::transform_env(simple_sender{}, ce));
         }
 
         static_assert(test_std::sender<tagged_sender<true>>);
@@ -178,7 +178,7 @@ namespace
         {
             using type = decltype(Domain::transform_env(tagged_sender<true>{}, env{}));
             static_assert(std::same_as<env, type>);
-            assert(env{17} == Domain::transform_env(simple_sender{}, env{17}));
+            ASSERT(env{17} == Domain::transform_env(simple_sender{}, env{17}));
         }
     }
 
@@ -198,20 +198,20 @@ namespace
         static_assert(not noexcept(Domain().apply_sender(tag<false>{}, simple_sender{}, 0)));
         static_assert(not noexcept(Domain().apply_sender(tag<false>{}, simple_sender{}, 0, 0, 0)));
 
-        assert(17 == Domain().apply_sender(tag<true>{}, simple_sender{}, 17));
-        assert(15 == Domain().apply_sender(tag<true>{}, simple_sender{}, 4, 5, 6));
+        ASSERT(17 == Domain().apply_sender(tag<true>{}, simple_sender{}, 17));
+        ASSERT(15 == Domain().apply_sender(tag<true>{}, simple_sender{}, 4, 5, 6));
 
         bool flag{};
-        assert(&flag == &Domain().apply_sender(tag<true>{}, simple_sender{}, flag));
+        ASSERT(&flag == &Domain().apply_sender(tag<true>{}, simple_sender{}, flag));
     }
 }
 
 // ----------------------------------------------------------------------------
 
-auto main() -> int
+TEST(exec_domain_default)
 {
     test_std::default_domain domain{};
     test_transform_sender(domain);
     test_transform_env(domain);
     test_apply_sender(domain);
-}
+}

src/beman/execution26/tests/exec-fwd-env.pass.cpp

@@ -51,7 +51,7 @@ namespace
     };
 }
 
-auto main(int ac, char*[]) -> int
+TEST(exec_fwd_env)
 {
     static_assert(std::same_as<test_std::forwarding_query_t const,
                                decltype(test_std::forwarding_query)>);
@@ -74,6 +74,6 @@ auto main(int ac, char*[]) -> int
     static_assert(test_std::forwarding_query(dynamic_query()));
     static_assert(test_std::forwarding_query(dynamic_query{true}));
     static_assert(not test_std::forwarding_query(dynamic_query{false}));
-    assert(test_std::forwarding_query(dynamic_query{ac == 1}));
-    assert(not test_std::forwarding_query(dynamic_query{ac != 1}));
-}
+    ASSERT(test_std::forwarding_query(dynamic_query{true}));
+    ASSERT(not test_std::forwarding_query(dynamic_query{false}));
+}