xref: /aosp_15_r20/external/pigweed/pw_preprocessor/arguments_test.cc (revision 61c4878ac05f98d0ceed94b57d316916de578985) 
1 // Copyright 2020 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
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
12 // License for the specific language governing permissions and limitations under
13 // the License.
14 
15 // Many of these tests are static asserts. If these compile, they pass. The TEST
16 // functions are used for organization only.
17 
18 #include <tuple>
19 
20 #include "pw_preprocessor/apply.h"
21 #include "pw_unit_test/framework.h"
22 
23 namespace pw {
24 namespace {
25 
26 #define EMPTY_ARG
27 
TEST(HasArgs,WithoutArguments)28 TEST(HasArgs, WithoutArguments) {
29   static_assert(PW_HAS_ARGS() == 0);
30   static_assert(PW_HAS_ARGS(/**/) == 0);
31   static_assert(PW_HAS_ARGS(/* uhm, hi */) == 0);
32   static_assert(PW_HAS_ARGS(EMPTY_ARG) == 0);
33 
34   // Test how the macro handles whitespace and comments.
35   // clang-format off
36   static_assert(PW_HAS_ARGS(     ) == 0);
37   static_assert(PW_HAS_ARGS(
38       ) == 0);
39   static_assert(PW_HAS_ARGS(
40       // wow
41       // This is a comment.
42       ) == 0);
43   // clang-format on
44 
45   static_assert(PW_EMPTY_ARGS() == 1);
46   static_assert(PW_EMPTY_ARGS(/* hello */) == 1);
47   static_assert(PW_EMPTY_ARGS(
48                     // hello
49                     /* goodbye */) == 1);
50 }
51 
TEST(HasArgs,WithArguments)52 TEST(HasArgs, WithArguments) {
53   static_assert(PW_HAS_ARGS(()) == 1);
54   static_assert(PW_HAS_ARGS(0) == 1);
55   static_assert(PW_HAS_ARGS(, ) == 1);
56   static_assert(PW_HAS_ARGS(a, b, c) == 1);
57   static_assert(PW_HAS_ARGS(PW_HAS_ARGS) == 1);
58   static_assert(PW_HAS_ARGS(PW_HAS_ARGS()) == 1);
59 
60   static_assert(PW_EMPTY_ARGS(0) == 0);
61   static_assert(PW_EMPTY_ARGS(, ) == 0);
62   static_assert(PW_EMPTY_ARGS(a, b, c) == 0);
63   static_assert(PW_EMPTY_ARGS(PW_HAS_ARGS) == 0);
64   static_assert(PW_EMPTY_ARGS(PW_HAS_ARGS()) == 0);
65 }
66 
TestFunc(int arg,...)67 constexpr int TestFunc(int arg, ...) { return arg; }
68 
69 #define CALL_FUNCTION(arg, ...) TestFunc(arg PW_COMMA_ARGS(__VA_ARGS__))
70 
71 template <typename T, typename... Args>
TemplateArgCount()72 constexpr T TemplateArgCount() {
73   return sizeof...(Args);
74 }
75 
76 #define COUNT_ARGS_TEMPLATE(...) \
77   TemplateArgCount<int PW_COMMA_ARGS(__VA_ARGS__)>()
78 
TEST(CommaVarargs,NoArguments)79 TEST(CommaVarargs, NoArguments) {
80   static_assert(TestFunc(0 PW_COMMA_ARGS()) == 0);
81   static_assert(TestFunc(1 /* whoa */ PW_COMMA_ARGS(
82                     /* this macro */) /* is cool! */) == 1);
83 
84   static_assert(TemplateArgCount<int PW_COMMA_ARGS()>() == 0);
85   static_assert(TemplateArgCount<int PW_COMMA_ARGS(/* nothing */)>() == 0);
86 
87   static_assert(CALL_FUNCTION(2) == 2);
88   static_assert(CALL_FUNCTION(3, ) == 3);
89   static_assert(CALL_FUNCTION(4, /* nothing */) == 4);
90 
91   static_assert(COUNT_ARGS_TEMPLATE() == 0);
92   static_assert(COUNT_ARGS_TEMPLATE(/* nothing */) == 0);
93 }
94 
TEST(CommaVarargs,WithArguments)95 TEST(CommaVarargs, WithArguments) {
96   static_assert(TestFunc(0 PW_COMMA_ARGS(1)) == 0);
97   static_assert(TestFunc(1 PW_COMMA_ARGS(1, 2)) == 1);
98   static_assert(TestFunc(2 PW_COMMA_ARGS(1, 2, "three")) == 2);
99 
100   static_assert(TemplateArgCount<int PW_COMMA_ARGS(bool)>() == 1);
101   static_assert(TemplateArgCount<int PW_COMMA_ARGS(char, const char*)>() == 2);
102   static_assert(TemplateArgCount<int PW_COMMA_ARGS(int, char, const char*)>() ==
103                 3);
104 
105   static_assert(CALL_FUNCTION(3) == 3);
106   static_assert(CALL_FUNCTION(4, ) == 4);
107   static_assert(CALL_FUNCTION(5, /* nothing */) == 5);
108 
109   static_assert(COUNT_ARGS_TEMPLATE(int) == 1);
110   static_assert(COUNT_ARGS_TEMPLATE(int, int) == 2);
111   static_assert(COUNT_ARGS_TEMPLATE(int, int, int) == 3);
112 }
113 
TEST(CommaVarargs,EmptyFinalArgument)114 TEST(CommaVarargs, EmptyFinalArgument) {
115   static_assert(COUNT_ARGS_TEMPLATE(EMPTY_ARG) == 0);
116   static_assert(COUNT_ARGS_TEMPLATE(int, ) == 1);
117   static_assert(COUNT_ARGS_TEMPLATE(int, EMPTY_ARG) == 1);
118   static_assert(COUNT_ARGS_TEMPLATE(int, /* EMPTY_ARG */) == 1);
119   static_assert(COUNT_ARGS_TEMPLATE(int, int, ) == 2);
120   static_assert(COUNT_ARGS_TEMPLATE(int, int, int, ) == 3);
121   static_assert(COUNT_ARGS_TEMPLATE(int, int, int, EMPTY_ARG) == 3);
122 }
123 
124 // This test demonstrates that PW_COMMA_ARGS behaves unexpectedly when it is
125 // used when invoking another macro. DO NOT use PW_COMMA_ARGS when invoking
126 // another macro!
127 #define BAD_DEMO(fmt, ...) _BAD_DEMO_ADD_123(fmt PW_COMMA_ARGS(__VA_ARGS__))
128 
129 #define _BAD_DEMO_ADD_123(fmt, ...) \
130   _CAPTURE_ARGS_AS_TUPLE("%d: " fmt, 123 PW_COMMA_ARGS(__VA_ARGS__))
131 
132 #define _CAPTURE_ARGS_AS_TUPLE(...) std::make_tuple(__VA_ARGS__)
133 
TEST(CommaVarargs,MisbehavesWithMacroToMacroUse_NoArgs_ArgsAreOkay)134 TEST(CommaVarargs, MisbehavesWithMacroToMacroUse_NoArgs_ArgsAreOkay) {
135   auto [a1, a2] = BAD_DEMO("Hello world");
136   EXPECT_STREQ(a1, "%d: Hello world");
137   EXPECT_EQ(a2, 123);
138 }
139 
TEST(CommaVarargs,MisbehavesWithMacroToMacroUse_WithArgs_ArgsOutOfOrder)140 TEST(CommaVarargs, MisbehavesWithMacroToMacroUse_WithArgs_ArgsOutOfOrder) {
141   // If there is an additional argument, the order is incorrect! The 123
142   // argument should go before the "world?" argument, but it is inserted after.
143   // This would be a compilation error if these arguments were passed to printf.
144   // What's worse is that this can silently fail if the arguments happen to be
145   // compatible types.
146   const auto [a1, a2, a3] = BAD_DEMO("Hello %s", "world?");
147   EXPECT_STREQ(a1, "%d: Hello %s");
148   EXPECT_STREQ(a2, "world?");
149   EXPECT_EQ(a3, 123);
150 }
151 
TEST(CountArgs,Zero)152 TEST(CountArgs, Zero) {
153   static_assert(PW_MACRO_ARG_COUNT() == 0);
154   static_assert(PW_MACRO_ARG_COUNT(/**/) == 0);
155   static_assert(PW_MACRO_ARG_COUNT(/* uhm, hi */) == 0);
156 
157   // clang-format off
158   static_assert(PW_MACRO_ARG_COUNT(     ) == 0);
159   static_assert(PW_MACRO_ARG_COUNT(
160       ) == 0);
161   static_assert(PW_MACRO_ARG_COUNT(
162       // wow
163       // This is a comment.
164       ) == 0);
165   // clang-format on
166 }
167 
TEST(CountArgs,Commas)168 TEST(CountArgs, Commas) {
169   // clang-format off
170   static_assert(PW_MACRO_ARG_COUNT(,) == 2);
171   static_assert(PW_MACRO_ARG_COUNT(,,) == 3);
172   static_assert(PW_MACRO_ARG_COUNT(,,,) == 4);
173   // clang-format on
174   static_assert(PW_MACRO_ARG_COUNT(, ) == 2);
175   static_assert(PW_MACRO_ARG_COUNT(, , ) == 3);
176   static_assert(PW_MACRO_ARG_COUNT(, , , ) == 4);
177 
178   static_assert(PW_MACRO_ARG_COUNT(a, ) == 2);
179   static_assert(PW_MACRO_ARG_COUNT(a, , ) == 3);
180   static_assert(PW_MACRO_ARG_COUNT(a, b, c, ) == 4);
181 }
182 
TEST(CountArgs,Parentheses)183 TEST(CountArgs, Parentheses) {
184   static_assert(PW_MACRO_ARG_COUNT(()) == 1);
185   static_assert(PW_MACRO_ARG_COUNT((1, 2, 3, 4)) == 1);
186   static_assert(PW_MACRO_ARG_COUNT((1, 2, 3), (1, 2, 3, 4)) == 2);
187   static_assert(PW_MACRO_ARG_COUNT((), ()) == 2);
188   static_assert(PW_MACRO_ARG_COUNT((-), (o)) == 2);
189   static_assert(PW_MACRO_ARG_COUNT((, , (, , ), ), (123, 4)) == 2);
190   static_assert(PW_MACRO_ARG_COUNT(1, (2, 3, 4), (<5, 6>)) == 3);
191 }
192 
193 template <typename... Args>
FunctionArgCount(Args...)194 constexpr size_t FunctionArgCount(Args...) {
195   return sizeof...(Args);
196 }
197 
198 static_assert(FunctionArgCount() == 0);
199 static_assert(FunctionArgCount(1) == 1);
200 static_assert(FunctionArgCount(1, 2) == 2);
201 
TEST(CountFunctionArgs,NonEmptyLastArg)202 TEST(CountFunctionArgs, NonEmptyLastArg) {
203   static_assert(PW_FUNCTION_ARG_COUNT(a) == 1);
204   static_assert(PW_FUNCTION_ARG_COUNT(1, 2) == 2);
205   static_assert(PW_FUNCTION_ARG_COUNT(1, 2, 3) == 3);
206 }
207 
TEST(CountFunctionArgs,EmptyLastArg)208 TEST(CountFunctionArgs, EmptyLastArg) {
209   static_assert(PW_FUNCTION_ARG_COUNT() == 0);
210   static_assert(PW_FUNCTION_ARG_COUNT(a, ) == 1);
211   static_assert(PW_FUNCTION_ARG_COUNT(1, 2, ) == 2);
212   static_assert(PW_FUNCTION_ARG_COUNT(1, 2, 3, ) == 3);
213 
214   static_assert(PW_FUNCTION_ARG_COUNT(a, EMPTY_ARG) == 1);
215   static_assert(PW_FUNCTION_ARG_COUNT(1, 2, EMPTY_ARG) == 2);
216   static_assert(PW_FUNCTION_ARG_COUNT(1, 2, 3, EMPTY_ARG) == 3);
217 }
218 
Value(const char * str=nullptr)219 constexpr const char* Value(const char* str = nullptr) { return str; }
220 
TEST(LastArg,NonEmptyLastArg)221 TEST(LastArg, NonEmptyLastArg) {
222   constexpr const char* last = "last!";
223   static_assert(Value(PW_LAST_ARG(last)) == last);
224   static_assert(Value(PW_LAST_ARG(1, last)) == last);
225   static_assert(Value(PW_LAST_ARG(1, 2, last)) == last);
226 }
227 
TEST(LastArg,EmptyLastArg)228 TEST(LastArg, EmptyLastArg) {
229   static_assert(Value(PW_LAST_ARG()) == nullptr);
230   static_assert(Value(PW_LAST_ARG(1, )) == nullptr);
231   static_assert(Value(PW_LAST_ARG(1, 2, )) == nullptr);
232   static_assert(Value(PW_LAST_ARG(1, 2, 3, )) == nullptr);
233 }
234 
TEST(DropLastArg,NonEmptyLastArg)235 TEST(DropLastArg, NonEmptyLastArg) {
236   static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1)) == 0);
237   static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2)) == 1);
238   static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2, 3)) == 2);
239 }
240 
TEST(DropLastArg,EmptyLastArg)241 TEST(DropLastArg, EmptyLastArg) {
242   static_assert(FunctionArgCount(PW_DROP_LAST_ARG()) == 0);
243   static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, )) == 1);
244   static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2, )) == 2);
245   static_assert(FunctionArgCount(PW_DROP_LAST_ARG(1, 2, 3, )) == 3);
246 }
247 
TEST(DropLastArgIfEmpty,NonEmptyLastArg)248 TEST(DropLastArgIfEmpty, NonEmptyLastArg) {
249   static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1)) == 1);
250   static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2)) == 2);
251   static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2, 3)) == 3);
252 }
253 
TEST(DropLastArgIfEmpty,EmptyLastArg)254 TEST(DropLastArgIfEmpty, EmptyLastArg) {
255   static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY()) == 0);
256   static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, )) == 1);
257   static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2, )) == 2);
258   static_assert(FunctionArgCount(PW_DROP_LAST_ARG_IF_EMPTY(1, 2, 3, )) == 3);
259 }
260 
261 // This test demonstrates that PW_DROP_LAST_ARG_IF_EMPTY behaves unexpectedly
262 // when it is used when invoking another macro. DO NOT use
263 // PW_DROP_LAST_ARG_IF_EMPTY when invoking another macro!
264 #define BAD_DROP_LAST_DEMO(fmt, ...) \
265   _BAD_DROP_LAST_DEMO_ADD_123(PW_DROP_LAST_ARG_IF_EMPTY(fmt, __VA_ARGS__))
266 
267 #define _BAD_DROP_LAST_DEMO_ADD_123(fmt, ...) \
268   _CAPTURE_ARGS_AS_TUPLE("%d: " fmt,          \
269                          PW_DROP_LAST_ARG_IF_EMPTY(123, __VA_ARGS__))
270 
TEST(DropLastArgIfEmpty,EmptyLastArgArgsLoseOrder)271 TEST(DropLastArgIfEmpty, EmptyLastArgArgsLoseOrder) {
272   // If there are any additional arguments, the order is incorrect! The 123
273   // argument should go before the 3, 2, 1 arguments, but it is inserted after.
274   // This would be a compilation error if these arguments were passed to printf.
275   // What's worse is that this can silently fail if the arguments happen to be
276   // compatible types.
277   auto [a1, a2, a3, a4, a5] =
278       BAD_DROP_LAST_DEMO("Countdown in %d %d %d", 3, 2, 1, );
279   EXPECT_STREQ(a1, "%d: Countdown in %d %d %d");
280   EXPECT_EQ(a2, 3);
281   EXPECT_EQ(a3, 2);
282   EXPECT_EQ(a4, 1);
283   EXPECT_EQ(a5, 123);
284 }
285 
TEST(DropLastArgIfEmpty,NonEmptyLastArgArgsLoseOrder)286 TEST(DropLastArgIfEmpty, NonEmptyLastArgArgsLoseOrder) {
287   // If there are any additional arguments, the order is incorrect! The 123
288   // argument should go before the 3, 2, 1 arguments, but it is inserted after.
289   // This would be a compilation error if these arguments were passed to printf.
290   // What's worse is that this can silently fail if the arguments happen to be
291   // compatible types.
292   auto [a1, a2, a3, a4, a5] =
293       BAD_DROP_LAST_DEMO("Countdown in %d %d %d", 3, 2, 1);
294   EXPECT_STREQ(a1, "%d: Countdown in %d %d %d");
295   EXPECT_EQ(a2, 3);
296   EXPECT_EQ(a3, 2);
297   EXPECT_EQ(a4, 1);
298   EXPECT_EQ(a5, 123);
299 }
300 
301 // When PW_DROP_LAST_ARG_IF_EMPTY is used once, and there are no other
302 // modifications to __VA_ARGS__, then the order is kept.
303 #define DROP_LAST_DEMO(fmt, arg_a, arg_b, ...) \
304   _CAPTURE_ARGS_AS_TUPLE(                      \
305       "%d: " fmt, PW_DROP_LAST_ARG_IF_EMPTY(123, arg_a, arg_b, __VA_ARGS__))
306 
TEST(DropLastArgIfEmpty,EmptyLastArgAllArgsInOrder)307 TEST(DropLastArgIfEmpty, EmptyLastArgAllArgsInOrder) {
308   const auto [a1, a2, a3, a4, a5] =
309       DROP_LAST_DEMO("Countdown in %d %d %d", 3, 2, 1, );
310   EXPECT_STREQ(a1, "%d: Countdown in %d %d %d");
311   EXPECT_EQ(a2, 123);
312   EXPECT_EQ(a3, 3);
313   EXPECT_EQ(a4, 2);
314   EXPECT_EQ(a5, 1);
315 }
316 
TEST(DropLastArgIfEmpty,NonEmptyLastArgAllArgsInOrder)317 TEST(DropLastArgIfEmpty, NonEmptyLastArgAllArgsInOrder) {
318   const auto [a1, a2, a3, a4, a5] =
319       DROP_LAST_DEMO("Countdown in %d %d %d", 3, 2, 1);
320   EXPECT_STREQ(a1, "%d: Countdown in %d %d %d");
321   EXPECT_EQ(a2, 123);
322   EXPECT_EQ(a3, 3);
323   EXPECT_EQ(a4, 2);
324   EXPECT_EQ(a5, 1);
325 }
326 
327 #define SOME_VARIADIC_MACRO(...) PW_MACRO_ARG_COUNT(__VA_ARGS__)
328 
329 #define ANOTHER_VARIADIC_MACRO(arg, ...) SOME_VARIADIC_MACRO(__VA_ARGS__)
330 
331 #define ALWAYS_ONE_ARG(...) SOME_VARIADIC_MACRO((__VA_ARGS__))
332 
TEST(CountArgs,NestedMacros)333 TEST(CountArgs, NestedMacros) {
334   static_assert(SOME_VARIADIC_MACRO() == 0);
335   static_assert(SOME_VARIADIC_MACRO(X1) == 1);
336   static_assert(SOME_VARIADIC_MACRO(X1, X2) == 2);
337   static_assert(SOME_VARIADIC_MACRO(X1, X2, X3) == 3);
338   static_assert(SOME_VARIADIC_MACRO(X1, X2, X3, X4) == 4);
339   static_assert(SOME_VARIADIC_MACRO(X1, X2, X3, X4, X5) == 5);
340 
341   static_assert(ANOTHER_VARIADIC_MACRO() == 0);
342   static_assert(ANOTHER_VARIADIC_MACRO(X0) == 0);
343   static_assert(ANOTHER_VARIADIC_MACRO(X0, X1) == 1);
344   static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2) == 2);
345   static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3) == 3);
346   static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3, X4) == 4);
347   static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3, X4, X5) == 5);
348 
349   static_assert(ALWAYS_ONE_ARG() == 1);
350   static_assert(ALWAYS_ONE_ARG(X0) == 1);
351   static_assert(ALWAYS_ONE_ARG(X0, X1) == 1);
352   static_assert(ALWAYS_ONE_ARG(X0, X1, X2) == 1);
353   static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3) == 1);
354   static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3, X4) == 1);
355   static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3, X4, X5) == 1);
356 }
357 
358 /* Tests all supported arg counts. This test was generated by the following
359    Python 3 code:
360 for i in range(256 + 1):
361   args = [f'X{x}' for x in range(1, i + 1)]
362   print(f'  static_assert(PW_MACRO_ARG_COUNT({", ".join(args)}) == {i});')
363 */
364 // Most tests above 16 arguments were skipped to keep this a reasonable size.
TEST(CountArgs,AllSupported)365 TEST(CountArgs, AllSupported) {
366   // clang-format off
367   static_assert(PW_MACRO_ARG_COUNT() == 0);
368   static_assert(PW_MACRO_ARG_COUNT(X1) == 1);
369   static_assert(PW_MACRO_ARG_COUNT(X1, X2) == 2);
370   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3) == 3);
371   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4) == 4);
372   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5) == 5);
373   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6) == 6);
374   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7) == 7);
375   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8) == 8);
376   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9) == 9);
377   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) == 10);
378   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) == 11);
379   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) == 12);
380   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) == 13);
381   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) == 14);
382   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) == 15);
383   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) == 16);
384   static_assert(PW_MACRO_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) == 17);
385   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);
386   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);
387   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);
388   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);
389   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);
390   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, X65) == 65);
391   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, X65, X66, X67, X68, X69, X70, X71, X72, X73, X74, X75, X76, X77, X78, X79, X80, X81, X82, X83, X84, X85, X86, X87, X88, X89, X90, X91, X92, X93, X94, X95, X96, X97, X98, X99, X100, X101, X102, X103, X104, X105, X106, X107, X108, X109, X110, X111, X112, X113, X114, X115, X116, X117, X118, X119, X120, X121, X122, X123, X124, X125, X126, X127) == 127);
392   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, X65, X66, X67, X68, X69, X70, X71, X72, X73, X74, X75, X76, X77, X78, X79, X80, X81, X82, X83, X84, X85, X86, X87, X88, X89, X90, X91, X92, X93, X94, X95, X96, X97, X98, X99, X100, X101, X102, X103, X104, X105, X106, X107, X108, X109, X110, X111, X112, X113, X114, X115, X116, X117, X118, X119, X120, X121, X122, X123, X124, X125, X126, X127, X128) == 128);
393   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, X65, X66, X67, X68, X69, X70, X71, X72, X73, X74, X75, X76, X77, X78, X79, X80, X81, X82, X83, X84, X85, X86, X87, X88, X89, X90, X91, X92, X93, X94, X95, X96, X97, X98, X99, X100, X101, X102, X103, X104, X105, X106, X107, X108, X109, X110, X111, X112, X113, X114, X115, X116, X117, X118, X119, X120, X121, X122, X123, X124, X125, X126, X127, X128, X129) == 129);
394   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, X65, X66, X67, X68, X69, X70, X71, X72, X73, X74, X75, X76, X77, X78, X79, X80, X81, X82, X83, X84, X85, X86, X87, X88, X89, X90, X91, X92, X93, X94, X95, X96, X97, X98, X99, X100, X101, X102, X103, X104, X105, X106, X107, X108, X109, X110, X111, X112, X113, X114, X115, X116, X117, X118, X119, X120, X121, X122, X123, X124, X125, X126, X127, X128, X129, X130, X131, X132, X133, X134, X135, X136, X137, X138, X139, X140, X141, X142, X143, X144, X145, X146, X147, X148, X149, X150, X151, X152, X153, X154, X155, X156, X157, X158, X159, X160, X161, X162, X163, X164, X165, X166, X167, X168, X169, X170, X171, X172, X173, X174, X175, X176, X177, X178, X179, X180, X181, X182, X183, X184, X185, X186, X187, X188, X189, X190, X191, X192, X193, X194, X195, X196, X197, X198, X199, X200, X201, X202, X203, X204, X205, X206, X207, X208, X209, X210, X211, X212, X213, X214, X215, X216, X217, X218, X219, X220, X221, X222, X223, X224, X225, X226, X227, X228, X229, X230, X231, X232, X233, X234, X235, X236, X237, X238, X239, X240, X241, X242, X243, X244, X245, X246, X247, X248, X249, X250, X251, X252, X253, X254, X255) == 255);
395   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, X65, X66, X67, X68, X69, X70, X71, X72, X73, X74, X75, X76, X77, X78, X79, X80, X81, X82, X83, X84, X85, X86, X87, X88, X89, X90, X91, X92, X93, X94, X95, X96, X97, X98, X99, X100, X101, X102, X103, X104, X105, X106, X107, X108, X109, X110, X111, X112, X113, X114, X115, X116, X117, X118, X119, X120, X121, X122, X123, X124, X125, X126, X127, X128, X129, X130, X131, X132, X133, X134, X135, X136, X137, X138, X139, X140, X141, X142, X143, X144, X145, X146, X147, X148, X149, X150, X151, X152, X153, X154, X155, X156, X157, X158, X159, X160, X161, X162, X163, X164, X165, X166, X167, X168, X169, X170, X171, X172, X173, X174, X175, X176, X177, X178, X179, X180, X181, X182, X183, X184, X185, X186, X187, X188, X189, X190, X191, X192, X193, X194, X195, X196, X197, X198, X199, X200, X201, X202, X203, X204, X205, X206, X207, X208, X209, X210, X211, X212, X213, X214, X215, X216, X217, X218, X219, X220, X221, X222, X223, X224, X225, X226, X227, X228, X229, X230, X231, X232, X233, X234, X235, X236, X237, X238, X239, X240, X241, X242, X243, X244, X245, X246, X247, X248, X249, X250, X251, X252, X253, X254, X255, X256) == 256);
396   // clang-format on
397 }
398 
TEST(DelegateByArgCount,WithoutAndWithoutArguments)399 TEST(DelegateByArgCount, WithoutAndWithoutArguments) {
400 #define TEST_SUM0() (0)
401 #define TEST_SUM1(a) (a)
402 #define TEST_SUM2(a, b) ((a) + (b))
403 #define TEST_SUM3(a, b, c) ((a) + (b) + (c))
404 
405   static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM) == 0);
406   static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM, 5) == 5);
407   static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM, 1, 2) == 3);
408   static_assert(PW_DELEGATE_BY_ARG_COUNT(TEST_SUM, 1, 2, 3) == 6);
409 }
410 
411 #define SEMICOLON(...) ;
412 #define STRING_THING(index, name, arg) #arg
413 
414 #define TO_STRING_CASE(index, name, arg) \
415   case arg:                              \
416     return #arg
417 
418 #define APPLY_STRING_THING(...) PW_APPLY(STRING_THING, SEMICOLON, , __VA_ARGS__)
419 
ValueToStr(int value)420 constexpr const char* ValueToStr(int value) {
421   switch (value) {
422     PW_APPLY(TO_STRING_CASE, SEMICOLON, , 100, 200, 300, 400, 500);
423   }
424   return "Unknown value";
425 }
426 
TEST(ApplyMacroExpansion,OneStringValue)427 TEST(ApplyMacroExpansion, OneStringValue) {
428   constexpr const char* test = APPLY_STRING_THING(100);
429   EXPECT_STREQ("100", test);
430 }
431 
TEST(ApplyMacroExpansion,SwitchValue)432 TEST(ApplyMacroExpansion, SwitchValue) {
433   constexpr const char* test = ValueToStr(300);
434   EXPECT_STREQ("300", test);
435 }
436 
TEST(ApplyMacroExpansion,UnknownSwitchValue)437 TEST(ApplyMacroExpansion, UnknownSwitchValue) {
438   constexpr const char* test = ValueToStr(600);
439   EXPECT_STREQ("Unknown value", test);
440 }
441 
442 }  // namespace
443 }  // namespace pw
444