based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit 405cd0e9db6d67a8f3011662610cc528cd0ebc7c
parent ce9865aca018985b89bf4f640e42744805df879a
author Dimitrije Dobrota < mail@dimitrijedobrota.com >
date Thu, 1 May 2025 19:56:47 +0200

Fix NOLINT comments and products of this misuse

Diffstat:
M include/based/functional.hpp | + -
M include/based/instrumentation.hpp | ++++++ -----
M include/based/list.hpp | + -
M include/based/string.hpp | + -
M include/based/template.hpp | ++++++++++++++++ --------------
M include/based/type_traits.hpp | + -
M include/based/utility.hpp | + -
M test/source/buffer_test.cpp | ++ --
M test/source/curry_test.cpp | +++++++++++++++++++++++++++ --------------------
M test/source/max_test.cpp | +++++++++++++++ ---------------
M test/source/min_test.cpp | +++++++++++++++ ---------------
M test/source/scopeguard_test.cpp | ++++ ----
M test/source/signature_test.cpp | ++++++++ -------
M test/source/standard_traits_test.cpp | ++ --

14 files changed, 100 insertions(+), 89 deletions(-)

diff --git a/ include/based/functional.hpp b/ include/based/functional.hpp

@@ -23,7 +23,7 @@ class curried

}

public:
curried(Function function, CapturedArgs&&... args) // NOLINT explicit
curried(Function function, CapturedArgs&&... args) // NOLINT(*explicit*)
: m_function(function)
, m_captured(std::forward<CapturedArgs>(args)...)
{

diff --git a/ include/based/instrumentation.hpp b/ include/based/instrumentation.hpp

@@ -117,13 +117,13 @@ struct instrumented : instrumented_base


value_type value;

instrumented(const value_type& val) // NOLINT *-explicit-constructor
instrumented(const value_type& val) // NOLINT(*explicit*)
: value(std::move(val))
{
++counts[op::ctor_value];
}

instrumented(value_type&& val) // NOLINT *-explicit-constructor
instrumented(value_type&& val) // NOLINT(*explicit*)
: value(std::move(val))
{
++counts[op::ctor_value];

@@ -145,7 +145,7 @@ struct instrumented : instrumented_base

}

// self assign should be handled by the value_type
instrumented& operator=(const instrumented& val) // NOLINT cert-oop54-cpp
instrumented& operator=(const instrumented& val) // NOLINT(*cert-oop54-cpp*)
{
++counts[op::asgn_copy];
value = val.value;

@@ -153,7 +153,8 @@ struct instrumented : instrumented_base

}

// self assign should be handled by the value_type
instrumented& operator=(instrumented&& val) noexcept // NOLINT cert-oop54-cpp
instrumented& operator=(instrumented&& val
) noexcept // NOLINT(*cert-oop54-cpp*)
{
++counts[op::asgn_move];
value = std::move(val.value);

@@ -279,7 +280,7 @@ void count_operations(

std::begin(instrumented::names), std::end(instrumented::names)
);

std::mt19937 rng(0); // NOLINT cert-msc32-c cert-msc51-cpp
std::mt19937 rng(0); // NOLINT(*cert-msc32-c*, *cert-msc51-cpp*)
while (first <= last) {
std::vector<instrumented> vec(first);
std::iota(std::begin(vec), std::end(vec), 0.0);

diff --git a/ include/based/list.hpp b/ include/based/list.hpp

@@ -180,7 +180,7 @@ public:

}

list_type free(
list_type front, // NOLINT bugprone-easily-swappable-parameters
list_type front, // NOLINT(*swappable*)
list_type back
)
{

diff --git a/ include/based/string.hpp b/ include/based/string.hpp

@@ -9,7 +9,7 @@ namespace based

template<std::size_t n>
struct string_literal
{
// NOLINTNEXTLINE *-explicit-constructor *-avoid-c-arrays
// NOLINTNEXTLINE(*explicit*, *array*)
constexpr string_literal(const char (&str)[n])
: m_value(std::to_array(str))
{

diff --git a/ include/based/template.hpp b/ include/based/template.hpp

@@ -27,7 +27,7 @@ struct buffer

return sizeof(T) <= size && (alignment % sizeof(T)) == 0;
}

alignas(alignment) char m_space[size] = {0}; // NOLINT array
alignas(alignment) char m_space[size] = {0}; // NOLINT(*array*)

buffer() = default;

@@ -50,7 +50,7 @@ struct buffer

static_assert(std::is_trivially_destructible_v<T>);
static_assert(std::is_trivially_copyable_v<T>);

// NOLINTNEXTLINE owning-memory
// NOLINTNEXTLINE(*owning-memory*)
return ::new (static_cast<void*>(as<T>())) T(std::forward<Args>(args)...);
}

@@ -58,22 +58,24 @@ struct buffer

requires(valid_type<T>())
[[nodiscard]] T* as() noexcept
{
return reinterpret_cast<T*>(&m_space); // NOLINT reinterpret_cast
return reinterpret_cast<T*>(&m_space); // NOLINT(*reinterpret-cast*)
}

template<typename T>
requires(valid_type<T>())
[[nodiscard]] const T* as() const noexcept
{
return const_cast<buffer*>(this)->as<T>(); // NOLINT const_cast
return const_cast<buffer*>(this)->as<T>(); // NOLINT(*const-cast*)
}

void swap(buffer& that) noexcept
{
alignas(alignment) char tmp[size]; // NOLINT array
::memcpy(tmp, this->m_space, size); // NOLINT array
::memcpy(this->m_space, that.m_space, size); // NOLINT array
::memcpy(that.m_space, tmp, size); // NOLINT array
// NOLINTBEGIN(*array*)
alignas(alignment) char tmp[size];
::memcpy(tmp, this->m_space, size);
::memcpy(this->m_space, that.m_space, size);
::memcpy(that.m_space, tmp, size);
// NOLINTEND(*array*)
}
};

@@ -136,7 +138,7 @@ public:

std::is_trivially_copyable_v<Callable>;
})

function(CallableArg&& callable) // NOLINT explicit
function(CallableArg&& callable) // NOLINT(*explicit*)
: m_space(
std::in_place_type<Callable>, std::forward<CallableArg>(callable)
)

@@ -149,7 +151,7 @@ public:

{
return this->m_executor(
std::forward<CallArgs>(callargs)...,
const_cast<function*>(this) // NOLINT const_cast
const_cast<function*>(this) // NOLINT(*const-cast*)
);
}
};

@@ -167,13 +169,13 @@ class scopeguard

Func m_func;

public:
scopeguard(Func&& func) // NOLINT explicit
scopeguard(Func&& func) // NOLINT(*explicit*)
: m_func(std::move(func))
{
}

/*
scopeguard(const Func& func) // NOLINT explicit
scopeguard(const Func& func) // NOLINT(*explicit*)
: m_func(func)
{
}

@@ -200,13 +202,13 @@ class scopeguard<Func, false, false>

Func m_func;

public:
scopeguard(Func&& func) // NOLINT explicit
scopeguard(Func&& func) // NOLINT(*explicit*)
: m_func(std::move(func))
{
}

/*
scopeguard(const Func& func) // NOLINT explicit
scopeguard(const Func& func) // NOLINT(*explicit*)
: m_func(func)
{
}

diff --git a/ include/based/type_traits.hpp b/ include/based/type_traits.hpp

@@ -23,7 +23,7 @@ struct integral_constant

using value_type = T;
using type = integral_constant;

// NOLINTNEXTLINE explicit
// NOLINTNEXTLINE(*explicit*)
constexpr operator value_type() const noexcept { return value; }
constexpr value_type operator()() const noexcept { return value; }
};

diff --git a/ include/based/utility.hpp b/ include/based/utility.hpp

@@ -15,7 +15,7 @@ public:

{
}

operator bool() const noexcept // NOLINT explicit
operator bool() const noexcept // NOLINT(*explicit*)
{
return std::uncaught_exceptions() > m_count;
}

diff --git a/ test/source/buffer_test.cpp b/ test/source/buffer_test.cpp

@@ -14,7 +14,7 @@ TEST_CASE("valid type", "[template/buffer]")

STATIC_REQUIRE(buffer::valid_type<std::uint8_t>());
STATIC_REQUIRE_FALSE(buffer::valid_type<std::size_t>());

STATIC_REQUIRE_FALSE(buffer::valid_type<char[5]>()); // NOLINT array
STATIC_REQUIRE_FALSE(buffer::valid_type<char[5]>()); // NOLINT(*array*)
}

SECTION("big buffer")

@@ -23,7 +23,7 @@ TEST_CASE("valid type", "[template/buffer]")

STATIC_REQUIRE(buffer::valid_type<std::uint8_t>());
STATIC_REQUIRE(buffer::valid_type<std::size_t>());

STATIC_REQUIRE_FALSE(buffer::valid_type<char[5]>()); // NOLINT array
STATIC_REQUIRE_FALSE(buffer::valid_type<char[5]>()); // NOLINT(*array*)
}
}

diff --git a/ test/source/curry_test.cpp b/ test/source/curry_test.cpp

@@ -2,12 +2,17 @@


#include "based/functional.hpp"

// NOLINTBEGIN congnitive-complexity magic-number
// NOLINTBEGIN(*cognitive-complexity*, *magic*)

namespace
{

auto free_func(int a, double b, int c, double d)
{
return static_cast<int>(a + b + c + d);
};
}

} // namespace

TEST_CASE("free function", "[functional/curry]")
{

@@ -42,29 +47,31 @@ TEST_CASE("member function", "[functional/curry]")

{
struct test
{
auto func(int a, double b, int c, double d) const
[[nodiscard]] auto func(int a, double b, int c, double d) const
{
return static_cast<int>(a + b + c + d);
return static_cast<int>(m_x + a + b + c + d);
}

int m_x = 0;
};

const based::curried curried = &test::func;
test t;
test tmp;

REQUIRE(curried(std::ref(t))(1)(2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(t))(1)(2.0)(3, 4.0) == 10);
REQUIRE(curried(std::ref(t))(1)(2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(t))(1)(2.0, 3, 4.0) == 10);
REQUIRE(curried(std::ref(t))(1, 2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(t))(1, 2.0)(3, 4.0) == 10);
REQUIRE(curried(std::ref(t))(1, 2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(t))(1, 2.0, 3, 4.0) == 10);
REQUIRE(curried(std::ref(t), 1)(2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(t), 1)(2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(t), 1, 2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(t), 1, 2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(t), 1, 2.0, 3, 4.0) == 10);
REQUIRE(curried(std::ref(t), 1, 2.0, 3, 4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1)(2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1)(2.0)(3, 4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1)(2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1)(2.0, 3, 4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1, 2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1, 2.0)(3, 4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1, 2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1, 2.0, 3, 4.0) == 10);
REQUIRE(curried(std::ref(tmp), 1)(2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp), 1)(2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp), 1, 2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp), 1, 2.0, 3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp), 1, 2.0, 3, 4.0) == 10);
REQUIRE(curried(std::ref(tmp), 1, 2.0, 3, 4.0) == 10);
}

// NOLINTEND congnitive-complexity magic-number
// NOLINTEND(*cognitive-complexity*, *magic*)

diff --git a/ test/source/max_test.cpp b/ test/source/max_test.cpp

@@ -3,6 +3,8 @@

#include "based/type_traits.hpp"
#include "based/algorithm.hpp"

// NOLINTBEGIN(*const-arg*,*const-correctness*,*after-move, *access-moved)

TEST_CASE("max(literal, literal) = right", "[algorithm/max]")
{
using res_t = decltype(based::max(3, 4));

@@ -19,7 +21,7 @@ TEST_CASE("max(literal, literal) = left", "[algorithm/max]")


TEST_CASE("max(value, literal) = right", "[algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
int a = 3;

using res_t = decltype(based::max(a, 4));
REQUIRE(based::SameAs<int, res_t>);

@@ -28,7 +30,7 @@ TEST_CASE("max(value, literal) = right", "[algorithm/max]")


TEST_CASE("max(value, literal) = left", "[algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
int a = 4;

using res_t = decltype(based::max(a, 3));
REQUIRE(based::SameAs<int, res_t>);

@@ -37,7 +39,7 @@ TEST_CASE("max(value, literal) = left", "[algorithm/max]")


TEST_CASE("max(literal, value) = right", "[algorithm/max]")
{
int b = 4; // NOLINT misc-const-correctness
int b = 4;

using res_t = decltype(based::max(3, b));
REQUIRE(based::SameAs<int, res_t>);

@@ -46,7 +48,7 @@ TEST_CASE("max(literal, value) = right", "[algorithm/max]")


TEST_CASE("max(literal, value) = left", "[algorithm/max]")
{
int b = 3; // NOLINT misc-const-correctness
int b = 3;

using res_t = decltype(based::max(4, b));
REQUIRE(based::SameAs<int, res_t>);

@@ -131,7 +133,7 @@ TEST_CASE("max(const value, const value) = left", "[algorithm/max]")


TEST_CASE("max(value, const value) = right", "[algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
int a = 3;
const int b = 4;

using res_t = decltype(based::max(a, b));

@@ -141,7 +143,7 @@ TEST_CASE("max(value, const value) = right", "[algorithm/max]")


TEST_CASE("max(value, const value) = left", "[algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
int a = 4;
const int b = 3;

using res_t = decltype(based::max(a, b));

@@ -152,7 +154,7 @@ TEST_CASE("max(value, const value) = left", "[algorithm/max]")

TEST_CASE("max(const value, value) = right", "[algorithm/max]")
{
const int a = 3;
int b = 4; // NOLINT misc-const-correctness
int b = 4;

using res_t = decltype(based::max(a, b));
REQUIRE(based::SameAs<const int&, res_t>);

@@ -162,15 +164,13 @@ TEST_CASE("max(const value, value) = right", "[algorithm/max]")

TEST_CASE("max(const value, value) = left", "[algorithm/max]")
{
const int a = 4;
int b = 3; // NOLINT misc-const-correctness
int b = 3;

using res_t = decltype(based::max(a, b));
REQUIRE(based::SameAs<const int&, res_t>);
REQUIRE(based::max(a, b) == 4);
}

// NOLINTBEGIN move-const-arg

TEST_CASE("max(move, literal) = right", "[algorithm/max]")
{
int a = 3;

@@ -192,7 +192,7 @@ TEST_CASE("max(move, literal) = left", "[algorithm/max]")

TEST_CASE("max(move, value) = right", "[algorithm/max]")
{
int a = 3;
int b = 4; // NOLINT misc-const-correctness
int b = 4;

using res_t = decltype(based::max(std::move(a), b));
REQUIRE(based::SameAs<int, res_t>);

@@ -202,7 +202,7 @@ TEST_CASE("max(move, value) = right", "[algorithm/max]")

TEST_CASE("max(move, value) = left", "[algorithm/max]")
{
int a = 4;
int b = 3; // NOLINT misc-const-correctness
int b = 3;

using res_t = decltype(based::max(std::move(a), b));
REQUIRE(based::SameAs<int, res_t>);

@@ -249,7 +249,7 @@ TEST_CASE("max(literal, move) = left", "[algorithm/max]")


TEST_CASE("max(value, move) = right", "[algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
int a = 3;
int b = 4;

using res_t = decltype(based::max(a, std::move(b)));

@@ -259,7 +259,7 @@ TEST_CASE("max(value, move) = right", "[algorithm/max]")


TEST_CASE("max(value, move) = left", "[algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
int a = 4;
int b = 3;

using res_t = decltype(based::max(a, std::move(b)));

@@ -307,7 +307,7 @@ TEST_CASE("max(move, move) = left", "[algorithm/max]")

REQUIRE(based::max(std::move(a), std::move(b)) == 4);
}

// NOLINTEND move-const-arg
// NOLINTEND(*const-arg*,*const-correctness*,*after-move, *access-moved)

TEST_CASE("max-stability", "[algorithm/max]")
{

diff --git a/ test/source/min_test.cpp b/ test/source/min_test.cpp

@@ -3,6 +3,8 @@

#include "based/algorithm.hpp"
#include "based/type_traits.hpp"

// NOLINTBEGIN(*const-arg*,*const-correctness*,*after-move, *access-moved)

TEST_CASE("min(literal, literal) = left", "[algorithm/min]")
{
using res_t = decltype(based::min(3, 4));

@@ -19,7 +21,7 @@ TEST_CASE("min(literal, literal) = right", "[algorithm/min]")


TEST_CASE("min(value, literal) = left", "[algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
int a = 3;

using res_t = decltype(based::min(a, 4));
REQUIRE(based::SameAs<int, res_t>);

@@ -28,7 +30,7 @@ TEST_CASE("min(value, literal) = left", "[algorithm/min]")


TEST_CASE("min(value, literal) = right", "[algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
int a = 4;

using res_t = decltype(based::min(a, 3));
REQUIRE(based::SameAs<int, res_t>);

@@ -37,7 +39,7 @@ TEST_CASE("min(value, literal) = right", "[algorithm/min]")


TEST_CASE("min(literal, value) = left", "[algorithm/min]")
{
int b = 4; // NOLINT misc-const-correctness
int b = 4;

using res_t = decltype(based::min(3, b));
REQUIRE(based::SameAs<int, res_t>);

@@ -46,7 +48,7 @@ TEST_CASE("min(literal, value) = left", "[algorithm/min]")


TEST_CASE("min(literal, value) = right", "[algorithm/min]")
{
int b = 3; // NOLINT misc-const-correctness
int b = 3;

using res_t = decltype(based::min(4, b));
REQUIRE(based::SameAs<int, res_t>);

@@ -131,7 +133,7 @@ TEST_CASE("min(const value, const value) = right", "[algorithm/min]")


TEST_CASE("min(value, const value) = left", "[algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
int a = 3;
const int b = 4;

using res_t = decltype(based::min(a, b));

@@ -141,7 +143,7 @@ TEST_CASE("min(value, const value) = left", "[algorithm/min]")


TEST_CASE("min(value, const value) = right", "[algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
int a = 4;
const int b = 3;

using res_t = decltype(based::min(a, b));

@@ -152,7 +154,7 @@ TEST_CASE("min(value, const value) = right", "[algorithm/min]")

TEST_CASE("min(const value, value) = left", "[algorithm/min]")
{
const int a = 3;
int b = 4; // NOLINT misc-const-correctness
int b = 4;

using res_t = decltype(based::min(a, b));
REQUIRE(based::SameAs<const int&, res_t>);

@@ -162,15 +164,13 @@ TEST_CASE("min(const value, value) = left", "[algorithm/min]")

TEST_CASE("min(const value, value) = right", "[algorithm/min]")
{
const int a = 4;
int b = 3; // NOLINT misc-const-correctness
int b = 3;

using res_t = decltype(based::min(a, b));
REQUIRE(based::SameAs<const int&, res_t>);
REQUIRE(based::min(a, b) == 3);
}

// NOLINTBEGIN move-const-arg

TEST_CASE("min(move, literal) = left", "[algorithm/min]")
{
int a = 3;

@@ -192,7 +192,7 @@ TEST_CASE("min(move, literal) = right", "[algorithm/min]")

TEST_CASE("min(move, value) = left", "[algorithm/min]")
{
int a = 3;
int b = 4; // NOLINT misc-const-correctness
int b = 4;

using res_t = decltype(based::min(std::move(a), b));
REQUIRE(based::SameAs<int, res_t>);

@@ -202,7 +202,7 @@ TEST_CASE("min(move, value) = left", "[algorithm/min]")

TEST_CASE("min(move, value) = right", "[algorithm/min]")
{
int a = 4;
int b = 3; // NOLINT misc-const-correctness
int b = 3;

using res_t = decltype(based::min(std::move(a), b));
REQUIRE(based::SameAs<int, res_t>);

@@ -249,7 +249,7 @@ TEST_CASE("min(literal, move) = right", "[algorithm/min]")


TEST_CASE("min(value, move) = left", "[algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
int a = 3;
int b = 4;

using res_t = decltype(based::min(a, std::move(b)));

@@ -259,7 +259,7 @@ TEST_CASE("min(value, move) = left", "[algorithm/min]")


TEST_CASE("min(value, move) = right", "[algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
int a = 4;
int b = 3;

using res_t = decltype(based::min(a, std::move(b)));

@@ -307,7 +307,7 @@ TEST_CASE("min(move, move) = right", "[algorithm/min]")

REQUIRE(based::min(std::move(a), std::move(b)) == 3);
}

// NOLINTEND move-const-arg
// NOLINTEND(*const-arg*,*const-correctness*,*after-move, *access-moved)

TEST_CASE("min-stability", "[algorithm/min]")
{

diff --git a/ test/source/scopeguard_test.cpp b/ test/source/scopeguard_test.cpp

@@ -6,11 +6,11 @@


#include "based/template.hpp"

// NOLINTBEGIN cognitive-complexity
// NOLINTBEGIN(*cognitive-complexity*)

struct set
{
set(int& val)
explicit set(int& val)
: m_val(&val)
{
}

@@ -42,7 +42,7 @@ TEST_CASE("manual", "[template/scopeguard]")

{
int test = 0;
try {
based::scopeguard guard = set(test);
based::scopeguard guard = set(test); // NOLINT(*const*)
} catch (...) {
test *= 1;
}

@@ -131,4 +131,4 @@ TEST_CASE("exit", "[template/scopeguard]")

}
}

// NOLINTEND cognitive-complexity
// NOLINTEND(*cognitive-complexity*)

diff --git a/ test/source/signature_test.cpp b/ test/source/signature_test.cpp

@@ -4,20 +4,21 @@


#include "based/type_traits.hpp"

// NOLINTBEGIN cognitive-complexity
// NOLINTBEGIN(*cognitive-complexity*)

namespace
{

int free_func(const double& a, int&& b) noexcept(false) // NOLINT needed
// NOLINTNEXTLINE (*needed*)
int free_func(const double& a, int&& b) noexcept(false)
{
return static_cast<int>(a + std::move(b)); // NOLINT move
return static_cast<int>(a + b);
}

int free_func_noexcept(const double& a, int&& b) noexcept(true
) // NOLINT needed
// NOLINTNEXTLINE (*needed*)
int free_func_noexcept(const double& a, int&& b) noexcept(true)
{
return static_cast<int>(a + std::move(b)); // NOLINT move
return static_cast<int>(a + b);
}

} // namespace

@@ -474,4 +475,4 @@ TEST_CASE("const volatile noexcept rvalref", "[type_traits/signature]")

STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}

// NOLINTEND cognitive-complexity
// NOLINTEND(*cognitive-complexity*)

diff --git a/ test/source/standard_traits_test.cpp b/ test/source/standard_traits_test.cpp

@@ -4,7 +4,7 @@


#include "based/type_traits.hpp"

// NOLINTBEGIN array
// NOLINTBEGIN(*array*)

using based::SameAs;

@@ -155,4 +155,4 @@ TEST_CASE("remove_pointer", "[type_traits/remove_pointer]")

// clang-format on
}

// NOLINTEND array
// NOLINTEND(*array*)