based

0 #define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE

1

2 #include "based/enum/enum_flag.hpp"

3

4 #include <catch2/catch_test_macros.hpp>

5

6 #include "based/concepts/comparable/equality.hpp"

7 #include "based/concepts/comparable/greater.hpp"

8 #include "based/concepts/comparable/greater_equal.hpp"

9 #include "based/concepts/comparable/less.hpp"

10 #include "based/concepts/comparable/less_equal.hpp"

11 #include "based/concepts/is/same.hpp"

12 #include "based/types/types.hpp"

13

14 BASED_DECLARE_ENUM_FLAG(var, based::bu8, empty, a, b, c)

15 BASED_DEFINE_ENUM_FLAG(var, based::bu8, empty, a, b, c)

16

17 TEST_CASE("types", "[enum/enum_flag]")

18 {

19 STATIC_REQUIRE(requires { typename var; });

20 STATIC_REQUIRE(requires { var::empty; });

21 STATIC_REQUIRE(requires { var::a; });

22 STATIC_REQUIRE(requires { var::b; });

23 STATIC_REQUIRE(requires { var::c; });

24 STATIC_REQUIRE(var::enum_type::size == 4);

25 STATIC_REQUIRE(var::empty.value == 0);

26 STATIC_REQUIRE(var::a.value == 1);

27 STATIC_REQUIRE(var::b.value == 2);

28 STATIC_REQUIRE(var::c.value == 4);

29 }

30

31 TEST_CASE("operations", "[enum/enum_flag]")

32 {

33 using based::SameAs;

34

35 SECTION("COMPARE")

36 {

37 STATIC_REQUIRE(based::EqualityComparable<var::enum_type>);

38 STATIC_REQUIRE(!based::LessComparable<var::enum_type>);

39 STATIC_REQUIRE(!based::GreaterComparable<var::enum_type>);

40 STATIC_REQUIRE(!based::LessEqualComparable<var::enum_type>);

41 STATIC_REQUIRE(!based::GreaterEqualComparable<var::enum_type>);

42 }

43

44 SECTION("functions")

45 {

46 const auto var1 = var::a | var::b;

47

48 REQUIRE(var1.test(var::a));

49 REQUIRE(var1.test(var::b));

50 REQUIRE(!var1.test(var::c));

51

52 const auto var2 = ~var1;

53

54 REQUIRE(!var2.test(var::a));

55 REQUIRE(!var2.test(var::b));

56 REQUIRE(var2.test(var::c));

57

58 const auto var3 = var1 & var2;

59

60 REQUIRE(!var3.test(var::a));

61 REQUIRE(!var3.test(var::b));

62 REQUIRE(!var3.test(var::c));

63

64 const auto var4 = var1 ^ var2;

65

66 REQUIRE(var4.test(var::a));

67 REQUIRE(var4.test(var::b));

68 REQUIRE(var4.test(var::c));

69 }

70 }

71

72 TEST_CASE("enum_flag_wrapper", "[enum/enum_flag_wrapper]")

73 {

74 based::bu8 flags = 0;

75

76 {

77 auto wrapper = based::enum_flag_wrapper<var::enum_type>(flags);

78

79 wrapper |= var::a;

80 wrapper |= var::c;

81 }

82

83 REQUIRE(flags == 0x5);

84 }