based

0 #define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE

1

2 #include <catch2/catch_test_macros.hpp>

3

4 #include "based/concept/is_same.hpp"

5 #include "based/enum/enum.hpp"

6 #include "based/integral/types.hpp"

7

8 BASED_ENUM_BITMASK(var, based::U8) {

9 a = 1,

10 b = 2,

11 c = 4,

12 min = 0,

13 max = a | b | c, // NOLINT

14 };

15 BASED_ENUM_TRAITS_BITMASK(var, based::U8)

16

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

18 {

19 STATIC_REQUIRE(requires { typename var; });

20

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

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

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

24 }

25

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

27 {

28 using based::trait::IsSame;

29 SECTION("operators")

30 {

31 using namespace based::enumeration; // NOLINT(*namespace*)

32

33 SECTION("eql")

34 {

35 STATIC_REQUIRE(requires(var a, var b) {

36 {

37 a == b

38 } -> IsSame<bool>;

39 });

40

41 STATIC_REQUIRE(requires(var a, var b) {

42 {

43 a != b

44 } -> IsSame<bool>;

45 });

46 }

47

48 SECTION("or")

49 {

50 STATIC_REQUIRE(requires(var a, var b) {

51 {

52 a | b

53 } -> IsSame<var>;

54 });

55

56 STATIC_REQUIRE(requires(var a, var b) {

57 {

58 a |= b

59 } -> IsSame<var&>;

60 });

61 }

62

63 SECTION("and")

64 {

65 STATIC_REQUIRE(requires(var a, var b) {

66 {

67 a& b

68 } -> IsSame<var>;

69 });

70

71 STATIC_REQUIRE(requires(var a, var b) {

72 {

73 a &= b

74 } -> IsSame<var&>;

75 });

76 }

77

78 SECTION("xor")

79 {

80 STATIC_REQUIRE(requires(var a, var b) {

81 {

82 a ^ b

83 } -> IsSame<var>;

84 });

85

86 STATIC_REQUIRE(requires(var a, var b) {

87 {

88 a ^= b

89 } -> IsSame<var&>;

90 });

91 }

92

93 SECTION("not")

94 {

95 STATIC_REQUIRE(requires(var a) {

96 {

97 ~a

98 } -> IsSame<var>;

99 });

100 }

101

102 SECTION("set")

103 {

104 STATIC_REQUIRE(requires(var a, var b) {

105 {

106 set(a, b)

107 } -> IsSame<var&>;

108 });

109 }

110

111 SECTION("mask")

112 {

113 STATIC_REQUIRE(requires(var a, var b) {

114 {

115 mask(a, b)

116 } -> IsSame<var&>;

117 });

118 }

119

120 SECTION("tgl")

121 {

122 STATIC_REQUIRE(requires(var a, var b) {

123 {

124 tgl(a, b)

125 } -> IsSame<var&>;

126 });

127 }

128

129 SECTION("neg")

130 {

131 STATIC_REQUIRE(requires(var a) {

132 {

133 neg(a)

134 } -> IsSame<var&>;

135 });

136 }

137

138 SECTION("clear")

139 {

140 STATIC_REQUIRE(requires(var a, var b) {

141 {

142 clear(a, b)

143 } -> IsSame<var&>;

144 });

145 }

146

147 SECTION("test")

148 {

149 STATIC_REQUIRE(requires(var a, var b) {

150 {

151 test(a, b)

152 } -> IsSame<bool>;

153 });

154 }

155 }

156

157 SECTION("functions")

158 {

159 using namespace based::enumeration; // NOLINT(*namespace*)

160

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

162

163 REQUIRE(test(var1, var::a));

164 REQUIRE(test(var1, var::b));

165 REQUIRE(!test(var1, var::c));

166

167 const auto var2 = ~var1;

168

169 REQUIRE(!test(var2, var::a));

170 REQUIRE(!test(var2, var::b));

171 REQUIRE(test(var2, var::c));

172

173 const auto var3 = var1 & var2;

174

175 REQUIRE(!test(var3, var::a));

176 REQUIRE(!test(var3, var::b));

177 REQUIRE(!test(var3, var::c));

178

179 const auto var4 = var1 ^ var2;

180

181 REQUIRE(test(var4, var::a));

182 REQUIRE(test(var4, var::b));

183 REQUIRE(test(var4, var::c));

184 }

185 }

186

187 /*

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

189 {

190 auto flags = 0_u8;

191 {

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

193

194 wrapper |= var::a;

195 wrapper |= var::c;

196 }

197

198 REQUIRE(flags == 0x5_u8);

199 }

200 */