BlackMATov/enum.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/enum.hpp.git synced 2025-12-15 11:41:48 +07:00
Code Issues Packages Projects Releases Wiki Activity

bitfields logic operators tests

Browse Source
This commit is contained in:
BlackMATov
2020-12-18 16:12:40 +07:00
parent 288c2fc66b
commit 7cdc2885b0
2 changed files with 60 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
headers/enum.hpp/enum_bitflags.hpp
View File

@@ -143,18 +143,18 @@ namespace enum_hpp::bitflags
template < typename Enum template < typename Enum
, std::enable_if_t<std::is_enum_v<Enum>, int> = 0 > , std::enable_if_t<std::is_enum_v<Enum>, int> = 0 >
constexpr bool all_of(Enum l, Enum r) noexcept { constexpr bool all_of(Enum flags, Enum mask) noexcept {
return all_of(bitflags{l}, bitflags{r}); return all_of(bitflags{flags}, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool all_of(Enum l, bitflags<Enum> r) noexcept { constexpr bool all_of(Enum flags, bitflags<Enum> mask) noexcept {
return all_of(bitflags{l}, r); return all_of(bitflags{flags}, mask);
} }
template < typename Enum > template < typename Enum >
constexpr bool all_of(bitflags<Enum> l, Enum r) noexcept { constexpr bool all_of(bitflags<Enum> flags, Enum mask) noexcept {
return all_of(l, bitflags{r}); return all_of(flags, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
@@ -168,24 +168,24 @@ namespace enum_hpp::bitflags
template < typename Enum template < typename Enum
, std::enable_if_t<std::is_enum_v<Enum>, int> = 0 > , std::enable_if_t<std::is_enum_v<Enum>, int> = 0 >
constexpr bool any_of(Enum l, Enum r) noexcept { constexpr bool any_of(Enum flags, Enum mask) noexcept {
return any_of(bitflags{l}, bitflags{r}); return any_of(bitflags{flags}, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool any_of(Enum l, bitflags<Enum> r) noexcept { constexpr bool any_of(Enum flags, bitflags<Enum> mask) noexcept {
return any_of(bitflags{l}, r); return any_of(bitflags{flags}, mask);
} }
template < typename Enum > template < typename Enum >
constexpr bool any_of(bitflags<Enum> l, Enum r) noexcept { constexpr bool any_of(bitflags<Enum> flags, Enum mask) noexcept {
return any_of(l, bitflags{r}); return any_of(flags, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool any_of(bitflags<Enum> l, bitflags<Enum> r) noexcept { constexpr bool any_of(bitflags<Enum> flags, bitflags<Enum> mask) noexcept {
return r.as_raw() == 0 return mask.as_raw() == 0
|| (l.as_raw() & r.as_raw()) != 0; || (flags.as_raw() & mask.as_raw()) != 0;
} }
// //
@@ -194,24 +194,24 @@ namespace enum_hpp::bitflags
template < typename Enum template < typename Enum
, std::enable_if_t<std::is_enum_v<Enum>, int> = 0 > , std::enable_if_t<std::is_enum_v<Enum>, int> = 0 >
constexpr bool none_of(Enum l, Enum r) noexcept { constexpr bool none_of(Enum flags, Enum mask) noexcept {
return none_of(bitflags{l}, bitflags{r}); return none_of(bitflags{flags}, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool none_of(Enum l, bitflags<Enum> r) noexcept { constexpr bool none_of(Enum flags, bitflags<Enum> mask) noexcept {
return none_of(bitflags{l}, r); return none_of(bitflags{flags}, mask);
} }
template < typename Enum > template < typename Enum >
constexpr bool none_of(bitflags<Enum> l, Enum r) noexcept { constexpr bool none_of(bitflags<Enum> flags, Enum mask) noexcept {
return none_of(l, bitflags{r}); return none_of(flags, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool none_of(bitflags<Enum> l, bitflags<Enum> r) noexcept { constexpr bool none_of(bitflags<Enum> flags, bitflags<Enum> mask) noexcept {
return r.as_raw() != 0 return mask.as_raw() != 0
&& (l.as_raw() & r.as_raw()) == 0; && (flags.as_raw() & mask.as_raw()) == 0;
} }
// //
@@ -220,23 +220,23 @@ namespace enum_hpp::bitflags
template < typename Enum template < typename Enum
, std::enable_if_t<std::is_enum_v<Enum>, int> = 0 > , std::enable_if_t<std::is_enum_v<Enum>, int> = 0 >
constexpr bool any_except(Enum l, Enum r) noexcept { constexpr bool any_except(Enum flags, Enum mask) noexcept {
return any_except(bitflags{l}, bitflags{r}); return any_except(bitflags{flags}, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool any_except(Enum l, bitflags<Enum> r) noexcept { constexpr bool any_except(Enum flags, bitflags<Enum> mask) noexcept {
return any_except(bitflags{l}, r); return any_except(bitflags{flags}, mask);
} }
template < typename Enum > template < typename Enum >
constexpr bool any_except(bitflags<Enum> l, Enum r) noexcept { constexpr bool any_except(bitflags<Enum> flags, Enum mask) noexcept {
return any_except(l, bitflags{r}); return any_except(flags, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool any_except(bitflags<Enum> l, bitflags<Enum> r) noexcept { constexpr bool any_except(bitflags<Enum> flags, bitflags<Enum> mask) noexcept {
return any_of(l, ~r); return any_of(flags, ~mask);
} }
// //
@@ -245,23 +245,23 @@ namespace enum_hpp::bitflags
template < typename Enum template < typename Enum
, std::enable_if_t<std::is_enum_v<Enum>, int> = 0 > , std::enable_if_t<std::is_enum_v<Enum>, int> = 0 >
constexpr bool none_except(Enum l, Enum r) noexcept { constexpr bool none_except(Enum flags, Enum mask) noexcept {
return none_except(bitflags{l}, bitflags{r}); return none_except(bitflags{flags}, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool none_except(Enum l, bitflags<Enum> r) noexcept { constexpr bool none_except(Enum flags, bitflags<Enum> mask) noexcept {
return none_except(bitflags{l}, r); return none_except(bitflags{flags}, mask);
} }
template < typename Enum > template < typename Enum >
constexpr bool none_except(bitflags<Enum> l, Enum r) noexcept { constexpr bool none_except(bitflags<Enum> flags, Enum mask) noexcept {
return none_except(l, bitflags{r}); return none_except(flags, bitflags{mask});
} }
template < typename Enum > template < typename Enum >
constexpr bool none_except(bitflags<Enum> l, bitflags<Enum> r) noexcept { constexpr bool none_except(bitflags<Enum> flags, bitflags<Enum> mask) noexcept {
return none_of(l, ~r); return none_of(flags, ~mask);
} }
} }

20
untests/enum_bitflags_tests.cpp
View File

@@ -33,6 +33,26 @@ TEST_CASE("enum_bitflags") {
STATIC_CHECK((access::read_write ^ access::write) == bf::bitflags<access>(0x1)); STATIC_CHECK((access::read_write ^ access::write) == bf::bitflags<access>(0x1));
} }
SUBCASE("logic_operators") {
STATIC_CHECK(bf::bitflags{access::read} < bf::bitflags{access::write});
STATIC_CHECK_FALSE(bf::bitflags{access::write} < bf::bitflags{access::read});
STATIC_CHECK(bf::bitflags{access::read} <= bf::bitflags{access::write});
STATIC_CHECK_FALSE(bf::bitflags{access::write} <= bf::bitflags{access::read});
STATIC_CHECK(bf::bitflags{access::write} <= bf::bitflags{access::write});
STATIC_CHECK(bf::bitflags{access::write} > bf::bitflags{access::read});
STATIC_CHECK_FALSE(bf::bitflags{access::read} > bf::bitflags{access::write});
STATIC_CHECK(bf::bitflags{access::write} >= bf::bitflags{access::read});
STATIC_CHECK_FALSE(bf::bitflags{access::read} >= bf::bitflags{access::write});
STATIC_CHECK(bf::bitflags{access::read} >= bf::bitflags{access::read});
STATIC_CHECK(bf::bitflags{access::read} == bf::bitflags{access::read});
STATIC_CHECK_FALSE(bf::bitflags{access::read} == bf::bitflags{access::write});
STATIC_CHECK(bf::bitflags{access::read} != bf::bitflags{access::write});
STATIC_CHECK_FALSE(bf::bitflags{access::read} != bf::bitflags{access::read});
}
SUBCASE("bitflags_operators") { SUBCASE("bitflags_operators") {
STATIC_CHECK(0xFE == ~bf::bitflags{access::read}); STATIC_CHECK(0xFE == ~bf::bitflags{access::read});
STATIC_CHECK(~bf::bitflags{access::read} == 0xFE); STATIC_CHECK(~bf::bitflags{access::read} == 0xFE);