Wyatt Hepler | eb3304c | 2020-09-01 11:36:10 -0700 | [diff] [blame] | 1 | // Copyright 2020 The Pigweed Authors |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
Wyatt Hepler | 1a96094 | 2019-11-26 14:13:38 -0800 | [diff] [blame] | 4 | // use this file except in compliance with the License. You may obtain a copy of |
| 5 | // the License at |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 6 | // |
| 7 | // https://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 11 | // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
Wyatt Hepler | 1a96094 | 2019-11-26 14:13:38 -0800 | [diff] [blame] | 12 | // License for the specific language governing permissions and limitations under |
| 13 | // the License. |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 14 | |
| 15 | // Many of these tests are static asserts. If these compile, they pass. The TEST |
| 16 | // functions are used for organization only. |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 17 | |
Wyatt Hepler | eb3304c | 2020-09-01 11:36:10 -0700 | [diff] [blame] | 18 | #include "pw_preprocessor/arguments.h" |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 19 | |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 20 | #include <tuple> |
| 21 | |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 22 | #include "pw_unit_test/framework.h" |
| 23 | |
| 24 | namespace pw { |
| 25 | namespace { |
| 26 | |
Wyatt Hepler | 639ce3b | 2020-08-18 10:57:29 -0700 | [diff] [blame] | 27 | #define EMPTY_ARG |
| 28 | |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 29 | TEST(HasArgs, WithoutArguments) { |
| 30 | static_assert(PW_HAS_ARGS() == 0); |
| 31 | static_assert(PW_HAS_ARGS(/**/) == 0); |
| 32 | static_assert(PW_HAS_ARGS(/* uhm, hi */) == 0); |
Wyatt Hepler | 639ce3b | 2020-08-18 10:57:29 -0700 | [diff] [blame] | 33 | static_assert(PW_HAS_ARGS(EMPTY_ARG) == 0); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 34 | |
| 35 | // Test how the macro handles whitespace and comments. |
| 36 | // clang-format off |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 37 | static_assert(PW_HAS_ARGS( ) == 0); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 38 | static_assert(PW_HAS_ARGS( |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 39 | ) == 0); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 40 | static_assert(PW_HAS_ARGS( |
| 41 | // wow |
| 42 | // This is a comment. |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 43 | ) == 0); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 44 | // clang-format on |
| 45 | |
Wyatt Hepler | 639ce3b | 2020-08-18 10:57:29 -0700 | [diff] [blame] | 46 | static_assert(PW_EMPTY_ARGS() == 1); |
| 47 | static_assert(PW_EMPTY_ARGS(/* hello */) == 1); |
| 48 | static_assert(PW_EMPTY_ARGS( |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 49 | // hello |
| 50 | /* goodbye */) == 1); |
| 51 | } |
| 52 | |
| 53 | TEST(HasArgs, WithArguments) { |
| 54 | static_assert(PW_HAS_ARGS(()) == 1); |
| 55 | static_assert(PW_HAS_ARGS(0) == 1); |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 56 | static_assert(PW_HAS_ARGS(, ) == 1); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 57 | static_assert(PW_HAS_ARGS(a, b, c) == 1); |
| 58 | static_assert(PW_HAS_ARGS(PW_HAS_ARGS) == 1); |
| 59 | static_assert(PW_HAS_ARGS(PW_HAS_ARGS()) == 1); |
| 60 | |
Wyatt Hepler | 639ce3b | 2020-08-18 10:57:29 -0700 | [diff] [blame] | 61 | static_assert(PW_EMPTY_ARGS(0) == 0); |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 62 | static_assert(PW_EMPTY_ARGS(, ) == 0); |
Wyatt Hepler | 639ce3b | 2020-08-18 10:57:29 -0700 | [diff] [blame] | 63 | static_assert(PW_EMPTY_ARGS(a, b, c) == 0); |
| 64 | static_assert(PW_EMPTY_ARGS(PW_HAS_ARGS) == 0); |
| 65 | static_assert(PW_EMPTY_ARGS(PW_HAS_ARGS()) == 0); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | constexpr int TestFunc(int arg, ...) { return arg; } |
| 69 | |
| 70 | #define CALL_FUNCTION(arg, ...) TestFunc(arg PW_COMMA_ARGS(__VA_ARGS__)) |
| 71 | |
| 72 | template <typename T, typename... Args> |
| 73 | constexpr T TemplateArgCount() { |
| 74 | return sizeof...(Args); |
| 75 | } |
| 76 | |
| 77 | #define COUNT_ARGS_TEMPLATE(...) \ |
| 78 | TemplateArgCount<int PW_COMMA_ARGS(__VA_ARGS__)>() |
| 79 | |
| 80 | TEST(CommaVarargs, NoArguments) { |
| 81 | static_assert(TestFunc(0 PW_COMMA_ARGS()) == 0); |
| 82 | static_assert(TestFunc(1 /* whoa */ PW_COMMA_ARGS( |
| 83 | /* this macro */) /* is cool! */) == 1); |
| 84 | |
| 85 | static_assert(TemplateArgCount<int PW_COMMA_ARGS()>() == 0); |
| 86 | static_assert(TemplateArgCount<int PW_COMMA_ARGS(/* nothing */)>() == 0); |
| 87 | |
| 88 | static_assert(CALL_FUNCTION(2) == 2); |
| 89 | static_assert(CALL_FUNCTION(3, ) == 3); |
| 90 | static_assert(CALL_FUNCTION(4, /* nothing */) == 4); |
| 91 | |
| 92 | static_assert(COUNT_ARGS_TEMPLATE() == 0); |
| 93 | static_assert(COUNT_ARGS_TEMPLATE(/* nothing */) == 0); |
| 94 | } |
| 95 | |
| 96 | TEST(CommaVarargs, WithArguments) { |
| 97 | static_assert(TestFunc(0 PW_COMMA_ARGS(1)) == 0); |
| 98 | static_assert(TestFunc(1 PW_COMMA_ARGS(1, 2)) == 1); |
| 99 | static_assert(TestFunc(2 PW_COMMA_ARGS(1, 2, "three")) == 2); |
| 100 | |
| 101 | static_assert(TemplateArgCount<int PW_COMMA_ARGS(bool)>() == 1); |
| 102 | static_assert(TemplateArgCount<int PW_COMMA_ARGS(char, const char*)>() == 2); |
| 103 | static_assert(TemplateArgCount<int PW_COMMA_ARGS(int, char, const char*)>() == |
| 104 | 3); |
| 105 | |
| 106 | static_assert(CALL_FUNCTION(3) == 3); |
| 107 | static_assert(CALL_FUNCTION(4, ) == 4); |
| 108 | static_assert(CALL_FUNCTION(5, /* nothing */) == 5); |
| 109 | |
| 110 | static_assert(COUNT_ARGS_TEMPLATE(int) == 1); |
| 111 | static_assert(COUNT_ARGS_TEMPLATE(int, int) == 2); |
| 112 | static_assert(COUNT_ARGS_TEMPLATE(int, int, int) == 3); |
| 113 | } |
| 114 | |
Wyatt Hepler | 639ce3b | 2020-08-18 10:57:29 -0700 | [diff] [blame] | 115 | TEST(CommaVarargs, EmptyFinalArgument) { |
| 116 | static_assert(COUNT_ARGS_TEMPLATE(EMPTY_ARG) == 0); |
| 117 | static_assert(COUNT_ARGS_TEMPLATE(int, ) == 1); |
| 118 | static_assert(COUNT_ARGS_TEMPLATE(int, EMPTY_ARG) == 1); |
| 119 | static_assert(COUNT_ARGS_TEMPLATE(int, /* EMPTY_ARG */) == 1); |
| 120 | static_assert(COUNT_ARGS_TEMPLATE(int, int, ) == 2); |
| 121 | static_assert(COUNT_ARGS_TEMPLATE(int, int, int, ) == 3); |
| 122 | static_assert(COUNT_ARGS_TEMPLATE(int, int, int, EMPTY_ARG) == 3); |
| 123 | } |
| 124 | |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 125 | // This test demonstrates that PW_COMMA_ARGS behaves unexpectedly when it is |
| 126 | // used when invoking another macro. DO NOT use PW_COMMA_ARGS when invoking |
| 127 | // another macro! |
| 128 | #define BAD_DEMO(fmt, ...) _BAD_DEMO_ADD_123(fmt PW_COMMA_ARGS(__VA_ARGS__)) |
| 129 | |
| 130 | #define _BAD_DEMO_ADD_123(fmt, ...) \ |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 131 | _BAD_DEMO_CAPTURE_ARGS("%d: " fmt, 123 PW_COMMA_ARGS(__VA_ARGS__)) |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 132 | |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 133 | #define _BAD_DEMO_CAPTURE_ARGS(...) std::make_tuple(__VA_ARGS__) |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 134 | |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 135 | TEST(CommaVarargs, MisbehavesWithMacroToMacroUse_NoArgs_ArgsAreOkay) { |
| 136 | auto [a1, a2] = BAD_DEMO("Hello world"); |
| 137 | EXPECT_STREQ(a1, "%d: Hello world"); |
| 138 | EXPECT_EQ(a2, 123); |
| 139 | } |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 140 | |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 141 | TEST(CommaVarargs, MisbehavesWithMacroToMacroUse_WithArgs_ArgsOutOfOrder) { |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 142 | // If there is an additional argument, the order is incorrect! The 123 |
| 143 | // argument should go before the "world?" argument, but it is inserted after. |
| 144 | // This would be a compilation error if these arguments were passed to printf. |
| 145 | // What's worse is that this can silently fail if the arguments happen to be |
| 146 | // compatible types. |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 147 | const auto [a1, a2, a3] = BAD_DEMO("Hello %s", "world?"); |
| 148 | EXPECT_STREQ(a1, "%d: Hello %s"); |
| 149 | EXPECT_STREQ(a2, "world?"); |
| 150 | EXPECT_EQ(a3, 123); |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 153 | TEST(CountArgs, Zero) { |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 154 | static_assert(PW_MACRO_ARG_COUNT() == 0); |
| 155 | static_assert(PW_MACRO_ARG_COUNT(/**/) == 0); |
| 156 | static_assert(PW_MACRO_ARG_COUNT(/* uhm, hi */) == 0); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 157 | |
| 158 | // clang-format off |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 159 | static_assert(PW_MACRO_ARG_COUNT( ) == 0); |
| 160 | static_assert(PW_MACRO_ARG_COUNT( |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 161 | ) == 0); |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 162 | static_assert(PW_MACRO_ARG_COUNT( |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 163 | // wow |
| 164 | // This is a comment. |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 165 | ) == 0); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 166 | // clang-format on |
| 167 | } |
| 168 | |
| 169 | TEST(CountArgs, Commas) { |
| 170 | // clang-format off |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 171 | static_assert(PW_MACRO_ARG_COUNT(,) == 2); |
| 172 | static_assert(PW_MACRO_ARG_COUNT(,,) == 3); |
| 173 | static_assert(PW_MACRO_ARG_COUNT(,,,) == 4); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 174 | // clang-format on |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 175 | static_assert(PW_MACRO_ARG_COUNT(, ) == 2); |
| 176 | static_assert(PW_MACRO_ARG_COUNT(, , ) == 3); |
| 177 | static_assert(PW_MACRO_ARG_COUNT(, , , ) == 4); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | TEST(CountArgs, Parentheses) { |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 181 | static_assert(PW_MACRO_ARG_COUNT(()) == 1); |
| 182 | static_assert(PW_MACRO_ARG_COUNT((1, 2, 3, 4)) == 1); |
| 183 | static_assert(PW_MACRO_ARG_COUNT((1, 2, 3), (1, 2, 3, 4)) == 2); |
| 184 | static_assert(PW_MACRO_ARG_COUNT((), ()) == 2); |
| 185 | static_assert(PW_MACRO_ARG_COUNT((-), (o)) == 2); |
| 186 | static_assert(PW_MACRO_ARG_COUNT((, , (, , ), ), (123, 4)) == 2); |
| 187 | static_assert(PW_MACRO_ARG_COUNT(1, (2, 3, 4), (<5, 6>)) == 3); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 188 | } |
| 189 | |
Wyatt Hepler | 880cd68 | 2020-08-18 16:15:48 -0700 | [diff] [blame] | 190 | template <typename... Args> |
| 191 | constexpr size_t FunctionArgCount(Args...) { |
| 192 | return sizeof...(Args); |
| 193 | } |
| 194 | |
| 195 | static_assert(FunctionArgCount() == 0); |
| 196 | static_assert(FunctionArgCount(1) == 1); |
| 197 | static_assert(FunctionArgCount(1, 2) == 2); |
| 198 | |
| 199 | TEST(CountFunctionArgs, NonEmptyLastArg) { |
| 200 | static_assert(PW_FUNCTION_ARG_COUNT(a) == 1); |
| 201 | static_assert(PW_FUNCTION_ARG_COUNT(1, 2) == 2); |
| 202 | static_assert(PW_FUNCTION_ARG_COUNT(1, 2, 3) == 3); |
| 203 | } |
| 204 | |
| 205 | TEST(CountFunctionArgs, EmptyLastArg) { |
| 206 | static_assert(PW_FUNCTION_ARG_COUNT() == 0); |
| 207 | static_assert(PW_FUNCTION_ARG_COUNT(a, ) == 1); |
| 208 | static_assert(PW_FUNCTION_ARG_COUNT(1, 2, ) == 2); |
| 209 | static_assert(PW_FUNCTION_ARG_COUNT(1, 2, 3, ) == 3); |
| 210 | |
| 211 | static_assert(PW_FUNCTION_ARG_COUNT(a, EMPTY_ARG) == 1); |
| 212 | static_assert(PW_FUNCTION_ARG_COUNT(1, 2, EMPTY_ARG) == 2); |
| 213 | static_assert(PW_FUNCTION_ARG_COUNT(1, 2, 3, EMPTY_ARG) == 3); |
| 214 | } |
| 215 | |
| 216 | constexpr const char* Value(const char* str = nullptr) { return str; } |
| 217 | |
| 218 | TEST(LastArg, NonEmptyLastArg) { |
| 219 | constexpr const char* last = "last!"; |
| 220 | static_assert(Value(PW_LAST_ARG(last)) == last); |
| 221 | static_assert(Value(PW_LAST_ARG(1, last)) == last); |
| 222 | static_assert(Value(PW_LAST_ARG(1, 2, last)) == last); |
| 223 | } |
| 224 | |
| 225 | TEST(LastArg, EmptyLastArg) { |
| 226 | static_assert(Value(PW_LAST_ARG()) == nullptr); |
| 227 | static_assert(Value(PW_LAST_ARG(1, )) == nullptr); |
| 228 | static_assert(Value(PW_LAST_ARG(1, 2, )) == nullptr); |
| 229 | static_assert(Value(PW_LAST_ARG(1, 2, 3, )) == nullptr); |
| 230 | } |
| 231 | |
| 232 | TEST(DropLastArg, NonEmptyLastArg) { |
| 233 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1)) == 0); |
| 234 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2)) == 1); |
| 235 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2, 3)) == 2); |
| 236 | } |
| 237 | |
| 238 | TEST(DropLastArg, EmptyLastArg) { |
| 239 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG()) == 0); |
| 240 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, )) == 1); |
| 241 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2, )) == 2); |
| 242 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2, 3, )) == 3); |
| 243 | } |
| 244 | |
| 245 | TEST(DropLastArgIfEmpty, NonEmptyLastArg) { |
| 246 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1)) == 1); |
| 247 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2)) == 2); |
| 248 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2, 3)) == 3); |
| 249 | } |
| 250 | |
| 251 | TEST(DropLastArgIfEmpty, EmptyLastArg) { |
| 252 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY()) == 0); |
| 253 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, )) == 1); |
| 254 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2, )) == 2); |
| 255 | static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2, 3, )) == 3); |
| 256 | } |
| 257 | |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 258 | #define SOME_VARIADIC_MACRO(...) PW_MACRO_ARG_COUNT(__VA_ARGS__) |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 259 | |
| 260 | #define ANOTHER_VARIADIC_MACRO(arg, ...) SOME_VARIADIC_MACRO(__VA_ARGS__) |
| 261 | |
| 262 | #define ALWAYS_ONE_ARG(...) SOME_VARIADIC_MACRO((__VA_ARGS__)) |
| 263 | |
| 264 | TEST(CountArgs, NestedMacros) { |
| 265 | static_assert(SOME_VARIADIC_MACRO() == 0); |
| 266 | static_assert(SOME_VARIADIC_MACRO(X1) == 1); |
| 267 | static_assert(SOME_VARIADIC_MACRO(X1, X2) == 2); |
| 268 | static_assert(SOME_VARIADIC_MACRO(X1, X2, X3) == 3); |
| 269 | static_assert(SOME_VARIADIC_MACRO(X1, X2, X3, X4) == 4); |
| 270 | static_assert(SOME_VARIADIC_MACRO(X1, X2, X3, X4, X5) == 5); |
| 271 | |
| 272 | static_assert(ANOTHER_VARIADIC_MACRO() == 0); |
| 273 | static_assert(ANOTHER_VARIADIC_MACRO(X0) == 0); |
| 274 | static_assert(ANOTHER_VARIADIC_MACRO(X0, X1) == 1); |
| 275 | static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2) == 2); |
| 276 | static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3) == 3); |
| 277 | static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3, X4) == 4); |
| 278 | static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3, X4, X5) == 5); |
| 279 | |
| 280 | static_assert(ALWAYS_ONE_ARG() == 1); |
| 281 | static_assert(ALWAYS_ONE_ARG(X0) == 1); |
| 282 | static_assert(ALWAYS_ONE_ARG(X0, X1) == 1); |
| 283 | static_assert(ALWAYS_ONE_ARG(X0, X1, X2) == 1); |
| 284 | static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3) == 1); |
| 285 | static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3, X4) == 1); |
| 286 | static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3, X4, X5) == 1); |
| 287 | } |
| 288 | |
| 289 | /* Tests all supported arg counts. This test was generated by the following |
| 290 | Python 3 code: |
| 291 | for i in range(64 + 1): |
| 292 | args = [f'X{x}' for x in range(1, i + 1)] |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 293 | print(f' static_assert(PW_MACRO_ARG_COUNT({", ".join(args)}) == {i}) ') |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 294 | */ |
| 295 | TEST(CountArgs, AllSupported) { |
| 296 | // clang-format off |
Wyatt Hepler | 5191f58 | 2020-08-24 09:26:23 -0700 | [diff] [blame^] | 297 | static_assert(PW_MACRO_ARG_COUNT() == 0); |
| 298 | static_assert(PW_MACRO_ARG_COUNT(X1) == 1); |
| 299 | static_assert(PW_MACRO_ARG_COUNT(X1, X2) == 2); |
| 300 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3) == 3); |
| 301 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4) == 4); |
| 302 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5) == 5); |
| 303 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6) == 6); |
| 304 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7) == 7); |
| 305 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8) == 8); |
| 306 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9) == 9); |
| 307 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) == 10); |
| 308 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) == 11); |
| 309 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) == 12); |
| 310 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) == 13); |
| 311 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) == 14); |
| 312 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) == 15); |
| 313 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) == 16); |
| 314 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) == 17); |
| 315 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) == 18); |
| 316 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) == 19); |
| 317 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20) == 20); |
| 318 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21) == 21); |
| 319 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22) == 22); |
| 320 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23) == 23); |
| 321 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24) == 24); |
| 322 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25) == 25); |
| 323 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26) == 26); |
| 324 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27) == 27); |
| 325 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28) == 28); |
| 326 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29) == 29); |
| 327 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30) == 30); |
| 328 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31) == 31); |
| 329 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32) == 32); |
| 330 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33) == 33); |
| 331 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34) == 34); |
| 332 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35) == 35); |
| 333 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36) == 36); |
| 334 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37) == 37); |
| 335 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38) == 38); |
| 336 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39) == 39); |
| 337 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40) == 40); |
| 338 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41) == 41); |
| 339 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42) == 42); |
| 340 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43) == 43); |
| 341 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44) == 44); |
| 342 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45) == 45); |
| 343 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46) == 46); |
| 344 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47) == 47); |
| 345 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48) == 48); |
| 346 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49) == 49); |
| 347 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50) == 50); |
| 348 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51) == 51); |
| 349 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52) == 52); |
| 350 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53) == 53); |
| 351 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54) == 54); |
| 352 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55) == 55); |
| 353 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56) == 56); |
| 354 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57) == 57); |
| 355 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57, X58) == 58); |
| 356 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57, X58, X59) == 59); |
| 357 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57, X58, X59, X60) == 60); |
| 358 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57, X58, X59, X60, X61) == 61); |
| 359 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57, X58, X59, X60, X61, X62) == 62); |
| 360 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57, X58, X59, X60, X61, X62, X63) == 63); |
| 361 | static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30, X31, X32, X33, X34, X35, X36, X37, X38, X39, X40, X41, X42, X43, X44, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54, X55, X56, X57, X58, X59, X60, X61, X62, X63, X64) == 64); |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 362 | // clang-format on |
| 363 | } |
| 364 | |
Robert Oliver | d1323f4 | 2020-04-27 12:05:16 -0400 | [diff] [blame] | 365 | TEST(DelegateByArgCount, WithoutAndWithoutArguments) { |
| 366 | #define TEST_SUM0() (0) |
| 367 | #define TEST_SUM1(a) (a) |
| 368 | #define TEST_SUM2(a, b) ((a) + (b)) |
| 369 | #define TEST_SUM3(a, b, c) ((a) + (b) + (c)) |
| 370 | |
| 371 | static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM) == 0); |
| 372 | static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM, 5) == 5); |
| 373 | static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM, 1, 2) == 3); |
| 374 | static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM, 1, 2, 3) == 6); |
| 375 | } |
| 376 | |
Alexei Frolov | c10c812 | 2019-11-01 16:31:19 -0700 | [diff] [blame] | 377 | } // namespace |
| 378 | } // namespace pw |