started to address clang-tidy reports

Author: dietmarkuehl

tests/beman/execution26/exec-connect.test.cpp

@@ -14,7 +14,7 @@
 // ----------------------------------------------------------------------------
 
 namespace {
-enum class kind { plain, domain };
+enum class kind: unsigned char { plain, domain };
 template <kind, test_std::receiver Receiver>
 struct state {
     using operation_state_concept = test_std::operation_state_t;
@@ -24,6 +24,7 @@ struct state {
     template <typename R>
     state(int value, R&& r) : value(value), receiver(std::forward<R>(r)) {}
     state(state&&) = delete;
+    ~state() = default;
     auto start() noexcept -> void {}
 };
 
@@ -41,8 +42,9 @@ struct rvalue_sender {
     using sender_concept = test_std::sender_t;
     int value{};
 
-    rvalue_sender(int value) : value(value) {}
+    explicit rvalue_sender(int value) : value(value) {}
     rvalue_sender(rvalue_sender&&) = default;
+    auto operator= (rvalue_sender&&) -> rvalue_sender& = default;
 
     template <typename Receiver>
     auto connect(Receiver&& receiver) && -> state<kind::plain, Receiver> {
@@ -59,8 +61,9 @@ struct receiver {
     int   value{};
     bool* set_stopped_called{};
 
-    receiver(int value, bool* set_stopped_called = {}) : value(value), set_stopped_called(set_stopped_called) {}
+    explicit receiver(int value, bool* set_stopped_called = {}) : value(value), set_stopped_called(set_stopped_called) {}
     receiver(receiver&&)                           = default;
+    auto operator=(receiver&&) -> receiver& = default;
     auto operator==(const receiver&) const -> bool = default;
 
     auto get_env() const noexcept -> env { return {this->value + 2}; }
@@ -91,8 +94,10 @@ struct domain_receiver {
     using receiver_concept = test_std::receiver_t;
     int value{};
 
-    domain_receiver(int value) : value(value) {}
+    explicit domain_receiver(int value) : value(value) {}
     domain_receiver(domain_receiver&&)                    = default;
+    auto operator= (domain_receiver&&) -> domain_receiver& = default;
+
     auto operator==(const domain_receiver&) const -> bool = default;
 
     auto get_env() const noexcept -> domain_env { return {}; }
@@ -217,12 +222,13 @@ auto test_connect_awaitable() -> void {
             this->iv = value;
             this->bv = true;
         }
-        auto set_error(::std::exception_ptr error) && noexcept -> void {
+        auto set_error(::std::exception_ptr const& error) && noexcept -> void {
             try {
                 std::rethrow_exception(error);
             } catch (const std::runtime_error&) {
                 this->bv = true;
             } catch (...) {
+                this->bv = false;
             }
         }
         auto set_stopped() && noexcept -> void {}
@@ -285,7 +291,7 @@ auto test_connect_with_awaiter() -> void {
         using receiver_concept = test_std::receiver_t;
         bool& result;
         auto  set_value(int i) && noexcept -> void { this->result = i == 17; }
-        auto  set_error(std::exception_ptr) && noexcept -> void {}
+        auto  set_error(std::exception_ptr const&) && noexcept -> void {}
         auto  set_stopped() && noexcept -> void {}
     };
 

tests/beman/execution26/exec-get-env.test.cpp

@@ -13,6 +13,8 @@ struct with_non_env;
 struct non_env {
   private:
     friend struct with_non_env;
+    non_env() = default;
+    non_env(non_env&&) = delete;
     ~non_env() = default;
 };
 struct with_non_env {

tests/beman/execution26/exec-sched.test.cpp

@@ -31,6 +31,8 @@ struct no_scheduler_concept {
 
 struct not_queryable {
     using scheduler_concept = test_std::scheduler_t;
+    not_queryable() = default;
+    not_queryable(not_queryable&&) = default;
     ~not_queryable()        = delete;
     auto schedule() -> sender<env<not_queryable>> { return {}; }
     auto operator==(const not_queryable&) const -> bool = default;
@@ -49,6 +51,8 @@ struct not_equality_comparable {
 struct not_copy_constructible {
     using scheduler_concept                               = test_std::scheduler_t;
     not_copy_constructible(const not_copy_constructible&) = delete;
+    not_copy_constructible(not_copy_constructible&&) = default;
+    ~not_copy_constructible() = default;
     auto schedule() -> sender<env<not_copy_constructible>> { return {}; }
     auto operator==(const not_copy_constructible&) const -> bool = default;
 };

tests/beman/execution26/exec-schedule.test.cpp

@@ -34,8 +34,9 @@ auto test_schedule(Scheduler&& sched) {
     if constexpr (Expect) {
         static_assert(noexcept(test_std::schedule(std::forward<Scheduler>(sched))) ==
                       noexcept(std::forward<Scheduler>(sched).schedule()));
+        auto value{sched.value};
         auto s = test_std::schedule(std::forward<Scheduler>(sched));
-        ASSERT(s.value == sched.value);
+        ASSERT(s.value == value);
     }
 }
 } // namespace

tests/beman/execution26/exec-then.test.cpp

@@ -147,7 +147,7 @@ auto test_then_multi_type() -> void {
 
 auto test_then_value() -> void {
     ASSERT(std::tuple{17} ==
-           *test_std::sync_wait(test_std::just(5, 12) | test_std::then([](int a, int b) { return a + b; })));
+           test_std::sync_wait(test_std::just(5, 12) | test_std::then([](int a, int b) { return a + b; })).value_or(0));
     ASSERT(std::tuple{17} ==
            test_std::sync_wait(test_std::just_error(17) | test_std::upon_error([](int a) { return a; })));
     ASSERT(std::tuple{17} ==
@@ -183,15 +183,16 @@ struct allocator_fun {
     std::pmr::polymorphic_allocator<> alloc;
     std::byte*                        data{nullptr};
 
-    allocator_fun(std::pmr::polymorphic_allocator<> alloc) : alloc(alloc), data(alloc.allocate(1)) {}
+    explicit allocator_fun(std::pmr::polymorphic_allocator<> alloc) : alloc(alloc), data(alloc.allocate(1)) {}
     allocator_fun(const allocator_fun&, std::pmr::polymorphic_allocator<> = {}) {}
-    allocator_fun(allocator_fun&& other) : alloc(other.alloc), data(std::exchange(other.data, nullptr)) {}
+    allocator_fun(allocator_fun&& other) noexcept: alloc(other.alloc), data(std::exchange(other.data, nullptr)) {}
     allocator_fun(allocator_fun&& other, std::pmr::polymorphic_allocator<> alloc)
         : alloc(alloc), data(alloc == other.alloc ? std::exchange(other.data, nullptr) : alloc.allocate(1)) {}
     ~allocator_fun() {
         if (this->data)
             this->alloc.deallocate(this->data, 1u);
     }
+    auto operator= (allocator_fun&&) -> allocator_fun = delete;
     auto operator()(auto&&...) const {}
 };
 

tests/beman/execution26/execution-queryable-concept.test.cpp

@@ -11,7 +11,7 @@ template <typename T>
 concept has_foo = test_std::detail::queryable<T> && requires(T t) { t.foo; };
 
 class non_destructible {
-    ~non_destructible() = default;
+    ~non_destructible() = delete;
 };
 
 template <typename T>

tests/beman/execution26/include/test/stop_token.hpp

@@ -9,6 +9,7 @@
 #include <test/execution.hpp>
 
 #include <algorithm>
+#include <array>
 #include <atomic>
 #include <cassert>
 #include <chrono>
@@ -50,7 +51,7 @@ inline auto test::stop_visible(Token token, Stop stop) -> void {
     //   was requested.
     // Reference: [thread.stoptoken.intro] p3
 
-    Token tokens[] = {token, token, token, token};
+    std::array<Token, 4> tokens{token, token, token, token};
 
     auto predicate = [](auto&& t) { return t.stop_requested(); };
     ASSERT((::std::ranges::none_of(tokens, predicate)));
@@ -82,7 +83,7 @@ inline auto test::stop_callback(Token token, Stop stop) -> void {
 
     struct Callback {
         Data* data;
-        Callback(Data* data) : data(data) {}
+        explicit Callback(Data* data) : data(data) {}
         auto operator()() {
             ++this->data->count;
             this->data->stop_requested = this->data->token.stop_requested();
@@ -91,7 +92,7 @@ inline auto test::stop_callback(Token token, Stop stop) -> void {
 
     Data data{token};
 
-    ::test_std::stop_callback_for_t<Token, Callback> cb0(token, &data);
+    ::test_std::stop_callback_for_t<Token, Callback> cb0(token, Callback{&data});
     ASSERT(data.count == 0);
     ASSERT(data.stop_requested == false);
     stop();
@@ -102,7 +103,7 @@ inline auto test::stop_callback(Token token, Stop stop) -> void {
         stop();
         ASSERT(data.count == 1);
 
-        ::test_std::stop_callback_for_t<Token, Callback> cb1(token, &data);
+        ::test_std::stop_callback_for_t<Token, Callback> cb1(token, Callback{&data});
         ASSERT(data.count == 2);
         stop();
         ASSERT(data.count == 2);
@@ -122,13 +123,13 @@ auto test::stop_callback_dtor_deregisters(Token token, Stop stop) -> void {
 
     struct Callback {
         bool* ptr;
-        Callback(bool* ptr) : ptr(ptr) {}
+        explicit Callback(bool* ptr) : ptr(ptr) {}
         auto operator()() { *this->ptr = true; }
     };
 
     bool flag{};
     ::std::invoke([token, &flag] {
-        ::test_std::stop_callback_for_t<Token, Callback> cb(token, &flag);
+        ::test_std::stop_callback_for_t<Token, Callback> cb(token, Callback{&flag});
         ASSERT(flag == false);
     });
 
@@ -164,7 +165,7 @@ inline auto test::stop_callback_dtor_other_thread(Token token, Stop stop) -> voi
     };
     struct Callback {
         Data* data;
-        Callback(Data* data) : data(data) {}
+        explicit Callback(Data* data) : data(data) {}
         auto operator()() -> void {
             using namespace ::std::chrono_literals;
             {
@@ -181,7 +182,7 @@ inline auto test::stop_callback_dtor_other_thread(Token token, Stop stop) -> voi
     Data data;
 
     using CB = ::test_std::stop_callback_for_t<Token, Callback>;
-    ::std::unique_ptr<CB> ptr(new CB(token, &data));
+    ::std::unique_ptr<CB> ptr(new CB(token, Callback{&data}));
 
     ::std::thread thread([&ptr, &data] {
         {
@@ -210,19 +211,23 @@ inline auto test::stop_callback_dtor_same_thread(Token token, Stop stop) -> void
     // - Then the deregistration does not block.
     // Reference: [stoptoken.concepts] p4
     struct Base {
+        Base() = default;
+        Base(Base&&) = delete;
         virtual ~Base() = default;
     };
     struct Callback {
         ::std::unique_ptr<Base>* self;
-        Callback(::std::unique_ptr<Base>* self) : self(self) {}
+        explicit Callback(::std::unique_ptr<Base>* self) : self(self) {}
+        Callback(Callback const&) = default;
+        Callback(Callback&&) = default;
         auto operator()() { this->self->reset(); }
     };
     struct Object : Base {
         ::test_std::stop_callback_for_t<Token, Callback> cb;
-        Object(Token token, ::std::unique_ptr<Base>* self) : cb(token, self) {}
+        Object(Token token, ::std::unique_ptr<Base>* self) : cb(std::move(token), Callback{self}) {}
     };
     ::std::unique_ptr<Base> ptr;
-    ptr.reset(new Object(token, &ptr));
+    ptr.reset(new Object(std::move(token), &ptr));
 
     ::std::atomic<bool> done{};
     ::std::thread       thread([&done] {

tests/beman/execution26/stopcallback-general.test.cpp

@@ -6,6 +6,7 @@
 #include <concepts>
 #include <type_traits>
 
+namespace {
 auto test_stop_callback_interface() -> void {
     // Reference: [stopcallback.general] p1
     struct ThrowInit {};
@@ -35,5 +36,6 @@ auto test_stop_callback_interface() -> void {
 
     ::test_std::stop_callback cb(ctoken, Callback(ThrowInit()));
 }
+}
 
 TEST(stopcallback_general) { test_stop_callback_interface(); }

tests/beman/execution26/stopsource-mem.test.cpp

@@ -4,6 +4,7 @@
 #include <beman/execution26/stop_token.hpp>
 #include "test/execution.hpp"
 
+namespace {
 auto test_stopsource_swap() -> void {
     // Plan:
     //  - Given two engaged stop sources.
@@ -119,6 +120,7 @@ auto test_stopsource_request_stop() -> void {
     ASSERT(res4 == false);
     ASSERT(not disengaged.stop_requested());
 }
+}
 
 TEST(stopsource_mem) {
     test_stopsource_swap();

tests/beman/execution26/stoptoken-mem.test.cpp

@@ -2,10 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include <beman/execution26/stop_token.hpp>
+#include <array>
 #include <memory>
 #include "test/execution.hpp"
 #include "test/stop_token.hpp"
 
+namespace {
 auto test_stop_token_swap() -> void {
     // Plan:
     // - Given two pairs of stop_tokens compare equal within the pair
@@ -15,8 +17,8 @@ auto test_stop_token_swap() -> void {
     // Reference: [stoptoken.mem] p1
 
     ::test_std::stop_source s0, s1;
-    ::test_std::stop_token  pair0[] = {s0.get_token(), s0.get_token()};
-    ::test_std::stop_token  pair1[] = {s1.get_token(), s1.get_token()};
+    ::std::array<::test_std::stop_token, 2>  pair0 = {s0.get_token(), s0.get_token()};
+    ::std::array<::test_std::stop_token, 2>  pair1 = {s1.get_token(), s1.get_token()};
 
     ASSERT(pair0[0] == pair0[1]);
     ASSERT(pair1[0] == pair1[1]);
@@ -85,6 +87,7 @@ auto test_stop_token_stop_possible() -> void {
     ASSERT(unstopped_token.stop_possible() == false);
     ASSERT(stopped_token.stop_possible() == true);
 }
+}
 
 TEST(stoptoken_mem) {
     static_assert(::test_std::stoppable_token<::test_std::stop_token>);