Google Git
Sign in
opensecura / 3p / google / pigweed / 003044ad3564ec7b9705e70604af65fa5b304b84 / . / pw_preprocessor / macro_arg_count_test.cc
blob: fe985c2074b979569af771ae9767c1e700536f0e [file] [log] [blame]
Alexei Frolovc10c8122019-11-01 16:31:19 -0700[diff] [blame]1// Copyright 2019 The Pigweed Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License"); you may not
Wyatt Hepler1a960942019-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 Frolovc10c8122019-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 Hepler1a960942019-11-26 14:13:38 -0800[diff] [blame]12// License for the specific language governing permissions and limitations under
13// the License.
Alexei Frolovc10c8122019-11-01 16:31:19 -0700[diff] [blame]14//
15// All of these tests are static asserts. If the test compiles, it has already
16// passed. The TEST functions are used for organization only.
17
18#include "pw_preprocessor/macro_arg_count.h"
19
20#include "pw_unit_test/framework.h"
21
22namespace pw {
23namespace {
24
25TEST(HasArgs, WithoutArguments) {
26 static_assert(PW_HAS_ARGS() == 0);
27 static_assert(PW_HAS_ARGS(/**/) == 0);
28 static_assert(PW_HAS_ARGS(/* uhm, hi */) == 0);
29
30 // Test how the macro handles whitespace and comments.
31 // clang-format off
32 static_assert(PW_HAS_ARGS( ) == 0); // NOLINT
33 static_assert(PW_HAS_ARGS(
34 ) == 0); // NOLINT
35 static_assert(PW_HAS_ARGS(
36 // wow
37 // This is a comment.
38 ) == 0); // NOLINT
39 // clang-format on
40
41 static_assert(PW_HAS_NO_ARGS() == 1);
42 static_assert(PW_HAS_NO_ARGS(/* hello */) == 1);
43 static_assert(PW_HAS_NO_ARGS(
44 // hello
45 /* goodbye */) == 1);
46}
47
48TEST(HasArgs, WithArguments) {
49 static_assert(PW_HAS_ARGS(()) == 1);
50 static_assert(PW_HAS_ARGS(0) == 1);
51 static_assert(PW_HAS_ARGS(, ) == 1); // NOLINT
52 static_assert(PW_HAS_ARGS(a, b, c) == 1);
53 static_assert(PW_HAS_ARGS(PW_HAS_ARGS) == 1);
54 static_assert(PW_HAS_ARGS(PW_HAS_ARGS()) == 1);
55
56 static_assert(PW_HAS_NO_ARGS(0) == 0);
57 static_assert(PW_HAS_NO_ARGS(, ) == 0); // NOLINT
58 static_assert(PW_HAS_NO_ARGS(a, b, c) == 0);
59 static_assert(PW_HAS_NO_ARGS(PW_HAS_ARGS) == 0);
60 static_assert(PW_HAS_NO_ARGS(PW_HAS_ARGS()) == 0);
61}
62
63constexpr int TestFunc(int arg, ...) { return arg; }
64
65#define CALL_FUNCTION(arg, ...) TestFunc(arg PW_COMMA_ARGS(__VA_ARGS__))
66
67template <typename T, typename... Args>
68constexpr T TemplateArgCount() {
69 return sizeof...(Args);
70}
71
72#define COUNT_ARGS_TEMPLATE(...) \
73 TemplateArgCount<int PW_COMMA_ARGS(__VA_ARGS__)>()
74
75TEST(CommaVarargs, NoArguments) {
76 static_assert(TestFunc(0 PW_COMMA_ARGS()) == 0);
77 static_assert(TestFunc(1 /* whoa */ PW_COMMA_ARGS(
78 /* this macro */) /* is cool! */) == 1);
79
80 static_assert(TemplateArgCount<int PW_COMMA_ARGS()>() == 0);
81 static_assert(TemplateArgCount<int PW_COMMA_ARGS(/* nothing */)>() == 0);
82
83 static_assert(CALL_FUNCTION(2) == 2);
84 static_assert(CALL_FUNCTION(3, ) == 3);
85 static_assert(CALL_FUNCTION(4, /* nothing */) == 4);
86
87 static_assert(COUNT_ARGS_TEMPLATE() == 0);
88 static_assert(COUNT_ARGS_TEMPLATE(/* nothing */) == 0);
89}
90
91TEST(CommaVarargs, WithArguments) {
92 static_assert(TestFunc(0 PW_COMMA_ARGS(1)) == 0);
93 static_assert(TestFunc(1 PW_COMMA_ARGS(1, 2)) == 1);
94 static_assert(TestFunc(2 PW_COMMA_ARGS(1, 2, "three")) == 2);
95
96 static_assert(TemplateArgCount<int PW_COMMA_ARGS(bool)>() == 1);
97 static_assert(TemplateArgCount<int PW_COMMA_ARGS(char, const char*)>() == 2);
98 static_assert(TemplateArgCount<int PW_COMMA_ARGS(int, char, const char*)>() ==
99 3);
100
101 static_assert(CALL_FUNCTION(3) == 3);
102 static_assert(CALL_FUNCTION(4, ) == 4);
103 static_assert(CALL_FUNCTION(5, /* nothing */) == 5);
104
105 static_assert(COUNT_ARGS_TEMPLATE(int) == 1);
106 static_assert(COUNT_ARGS_TEMPLATE(int, int) == 2);
107 static_assert(COUNT_ARGS_TEMPLATE(int, int, int) == 3);
108}
109
110TEST(CountArgs, Zero) {
111 static_assert(PW_ARG_COUNT() == 0);
112 static_assert(PW_ARG_COUNT(/**/) == 0);
113 static_assert(PW_ARG_COUNT(/* uhm, hi */) == 0);
114
115 // clang-format off
116 static_assert(PW_ARG_COUNT( ) == 0); // NOLINT
117 static_assert(PW_ARG_COUNT(
118 ) == 0); // NOLINT
119 static_assert(PW_ARG_COUNT(
120 // wow
121 // This is a comment.
122 ) == 0); // NOLINT
123 // clang-format on
124}
125
126TEST(CountArgs, Commas) {
127 // clang-format off
128 static_assert(PW_ARG_COUNT(,) == 2); // NOLINT
129 static_assert(PW_ARG_COUNT(,,) == 3); // NOLINT
130 static_assert(PW_ARG_COUNT(,,,) == 4); // NOLINT
131 // clang-format on
132 static_assert(PW_ARG_COUNT(, ) == 2); // NOLINT
133 static_assert(PW_ARG_COUNT(, , ) == 3); // NOLINT
134 static_assert(PW_ARG_COUNT(, , , ) == 4); // NOLINT
135}
136
137TEST(CountArgs, Parentheses) {
138 static_assert(PW_ARG_COUNT(()) == 1);
139 static_assert(PW_ARG_COUNT((1, 2, 3, 4)) == 1);
140 static_assert(PW_ARG_COUNT((1, 2, 3), (1, 2, 3, 4)) == 2);
141 static_assert(PW_ARG_COUNT((), ()) == 2);
142 static_assert(PW_ARG_COUNT((-), (o)) == 2);
143 static_assert(PW_ARG_COUNT((, , (, , ), ), (123, 4)) == 2); // NOLINT
144 static_assert(PW_ARG_COUNT(1, (2, 3, 4), (<5, 6>)) == 3);
145}
146
147#define SOME_VARIADIC_MACRO(...) PW_ARG_COUNT(__VA_ARGS__)
148
149#define ANOTHER_VARIADIC_MACRO(arg, ...) SOME_VARIADIC_MACRO(__VA_ARGS__)
150
151#define ALWAYS_ONE_ARG(...) SOME_VARIADIC_MACRO((__VA_ARGS__))
152
153TEST(CountArgs, NestedMacros) {
154 static_assert(SOME_VARIADIC_MACRO() == 0);
155 static_assert(SOME_VARIADIC_MACRO(X1) == 1);
156 static_assert(SOME_VARIADIC_MACRO(X1, X2) == 2);
157 static_assert(SOME_VARIADIC_MACRO(X1, X2, X3) == 3);
158 static_assert(SOME_VARIADIC_MACRO(X1, X2, X3, X4) == 4);
159 static_assert(SOME_VARIADIC_MACRO(X1, X2, X3, X4, X5) == 5);
160
161 static_assert(ANOTHER_VARIADIC_MACRO() == 0);
162 static_assert(ANOTHER_VARIADIC_MACRO(X0) == 0);
163 static_assert(ANOTHER_VARIADIC_MACRO(X0, X1) == 1);
164 static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2) == 2);
165 static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3) == 3);
166 static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3, X4) == 4);
167 static_assert(ANOTHER_VARIADIC_MACRO(X0, X1, X2, X3, X4, X5) == 5);
168
169 static_assert(ALWAYS_ONE_ARG() == 1);
170 static_assert(ALWAYS_ONE_ARG(X0) == 1);
171 static_assert(ALWAYS_ONE_ARG(X0, X1) == 1);
172 static_assert(ALWAYS_ONE_ARG(X0, X1, X2) == 1);
173 static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3) == 1);
174 static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3, X4) == 1);
175 static_assert(ALWAYS_ONE_ARG(X0, X1, X2, X3, X4, X5) == 1);
176}
177
178/* Tests all supported arg counts. This test was generated by the following
179 Python 3 code:
180for i in range(64 + 1):
181 args = [f'X{x}' for x in range(1, i + 1)]
182 print(f' static_assert(PW_ARG_COUNT({", ".join(args)}) == {i}) // NOLINT')
183*/
184TEST(CountArgs, AllSupported) {
185 // clang-format off
186 static_assert(PW_ARG_COUNT() == 0); // NOLINT
187 static_assert(PW_ARG_COUNT(X1) == 1); // NOLINT
188 static_assert(PW_ARG_COUNT(X1, X2) == 2); // NOLINT
189 static_assert(PW_ARG_COUNT(X1, X2, X3) == 3); // NOLINT
190 static_assert(PW_ARG_COUNT(X1, X2, X3, X4) == 4); // NOLINT
191 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5) == 5); // NOLINT
192 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6) == 6); // NOLINT
193 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7) == 7); // NOLINT
194 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8) == 8); // NOLINT
195 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9) == 9); // NOLINT
196 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) == 10); // NOLINT
197 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) == 11); // NOLINT
198 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) == 12); // NOLINT
199 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) == 13); // NOLINT
200 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) == 14); // NOLINT
201 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) == 15); // NOLINT
202 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) == 16); // NOLINT
203 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) == 17); // NOLINT
204 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) == 18); // NOLINT
205 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) == 19); // NOLINT
206 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20) == 20); // NOLINT
207 static_assert(PW_ARG_COUNT(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21) == 21); // NOLINT
208 static_assert(PW_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); // NOLINT
209 static_assert(PW_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); // NOLINT
210 static_assert(PW_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); // NOLINT
211 static_assert(PW_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); // NOLINT
212 static_assert(PW_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); // NOLINT
213 static_assert(PW_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); // NOLINT
214 static_assert(PW_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); // NOLINT
215 static_assert(PW_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); // NOLINT
216 static_assert(PW_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); // NOLINT
217 static_assert(PW_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); // NOLINT
218 static_assert(PW_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); // NOLINT
219 static_assert(PW_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); // NOLINT
220 static_assert(PW_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); // NOLINT
221 static_assert(PW_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); // NOLINT
222 static_assert(PW_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); // NOLINT
223 static_assert(PW_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); // NOLINT
224 static_assert(PW_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); // NOLINT
225 static_assert(PW_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); // NOLINT
226 static_assert(PW_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); // NOLINT
227 static_assert(PW_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); // NOLINT
228 static_assert(PW_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); // NOLINT
229 static_assert(PW_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); // NOLINT
230 static_assert(PW_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); // NOLINT
231 static_assert(PW_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); // NOLINT
232 static_assert(PW_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); // NOLINT
233 static_assert(PW_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); // NOLINT
234 static_assert(PW_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); // NOLINT
235 static_assert(PW_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); // NOLINT
236 static_assert(PW_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); // NOLINT
237 static_assert(PW_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); // NOLINT
238 static_assert(PW_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); // NOLINT
239 static_assert(PW_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); // NOLINT
240 static_assert(PW_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); // NOLINT
241 static_assert(PW_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); // NOLINT
242 static_assert(PW_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); // NOLINT
243 static_assert(PW_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); // NOLINT
244 static_assert(PW_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); // NOLINT
245 static_assert(PW_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); // NOLINT
246 static_assert(PW_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); // NOLINT
247 static_assert(PW_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); // NOLINT
248 static_assert(PW_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); // NOLINT
249 static_assert(PW_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); // NOLINT
250 static_assert(PW_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); // NOLINT
251 // clang-format on
252}
253
254} // namespace
255} // namespace pw