]> Git Repo - binutils.git/blob - gdb/unittests/enum-flags-selftests.c
Automatic date update in version.in
[binutils.git] / gdb / unittests / enum-flags-selftests.c
1 /* Self tests for enum-flags for GDB, the GNU debugger.
2
3    Copyright (C) 2016-2022 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "gdbsupport/enum-flags.h"
22 #include "gdbsupport/valid-expr.h"
23 #include "gdbsupport/selftest.h"
24
25 namespace selftests {
26 namespace enum_flags_tests {
27
28 /* The (real) enum types used in CHECK_VALID.  Their names match the
29    template parameter names of the templates defined by CHECK_VALID to
30    make it simpler to use.  They could be named differently.  */
31
32 /* A "real enum".  */
33 enum RE
34   {
35     RE_FLAG1 = 1 << 1,
36     RE_FLAG2 = 1 << 2,
37   };
38
39 /* Another "real enum".  */
40 enum RE2
41   {
42     RE2_FLAG1 = 1 << 1,
43     RE2_FLAG2 = 1 << 2,
44   };
45
46 /* An unsigned "real enum".  */
47 enum URE : unsigned
48   {
49     URE_FLAG1 = 1 << 1,
50     URE_FLAG2 = 1 << 2,
51     URE_FLAG3 = 0xffffffff,
52   };
53
54 /* A non-flags enum.  */
55 enum NF
56   {
57     NF_FLAG1 = 1 << 1,
58     NF_FLAG2 = 1 << 2,
59   };
60
61 /* The corresponding "enum flags" types.  */
62 DEF_ENUM_FLAGS_TYPE (RE, EF);
63 DEF_ENUM_FLAGS_TYPE (RE2, EF2);
64 DEF_ENUM_FLAGS_TYPE (URE, UEF);
65
66 #if HAVE_IS_TRIVIALLY_COPYABLE
67
68 /* So that std::vectors of types that have enum_flags fields can
69    reallocate efficiently memcpy.  */
70 gdb_static_assert (std::is_trivially_copyable<EF>::value);
71
72 #endif
73
74 /* A couple globals used as lvalues in the CHECK_VALID expressions
75    below.  Their names (and types) match the uppercase type names
76    exposed by CHECK_VALID just to make the expressions easier to
77    follow.  */
78 static RE re ATTRIBUTE_UNUSED;
79 static EF ef ATTRIBUTE_UNUSED;
80
81 /* First, compile-time tests that:
82
83    - make sure that incorrect operations with mismatching enum types
84      are caught at compile time.
85
86    - make sure that the same operations but involving the right enum
87      types do compile and that they return the correct type.
88 */
89
90 #define CHECK_VALID(VALID, EXPR_TYPE, EXPR)             \
91   CHECK_VALID_EXPR_6 (EF, RE, EF2, RE2, UEF, URE, VALID, EXPR_TYPE, EXPR)
92
93 typedef std::underlying_type<RE>::type und;
94
95 /* Test construction / conversion from/to different types.  */
96
97 /* RE/EF -> underlying (explicit) */
98 CHECK_VALID (true,  und,  und (RE ()))
99 CHECK_VALID (true,  und,  und (EF ()))
100
101 /* RE/EF -> int (explicit) */
102 CHECK_VALID (true,  int,  int (RE ()))
103 CHECK_VALID (true,  int,  int (EF ()))
104
105 /* other -> RE */
106
107 /* You can construct a raw enum value from an int explicitly to punch
108    a hole in the type system if need to.  */
109 CHECK_VALID (true,  RE,   RE (1))
110 CHECK_VALID (true,  RE,   RE (RE2 ()))
111 CHECK_VALID (false, void, RE (EF2 ()))
112 CHECK_VALID (true,  RE,   RE (RE ()))
113 CHECK_VALID (false, void, RE (EF ()))
114
115 /* other -> EF.  */
116
117 /* As expected, enum-flags is a stronger type than the backing raw
118    enum.  Unlike with raw enums, you can't construct an enum flags
119    from an integer nor from an unrelated enum type explicitly.  Add an
120    intermediate conversion via the raw enum if you really need it.  */
121 CHECK_VALID (false, void, EF (1))
122 CHECK_VALID (false, void, EF (1u))
123 CHECK_VALID (false, void, EF (RE2 ()))
124 CHECK_VALID (false, void, EF (EF2 ()))
125 CHECK_VALID (true,  EF,   EF (RE ()))
126 CHECK_VALID (true,  EF,   EF (EF ()))
127
128 /* Test operators.  */
129
130 /* operator OP (raw_enum, int) */
131
132 CHECK_VALID (false, void, RE () | 1)
133 CHECK_VALID (false, void, RE () & 1)
134 CHECK_VALID (false, void, RE () ^ 1)
135
136 /* operator OP (int, raw_enum) */
137
138 CHECK_VALID (false, void, 1 | RE ())
139 CHECK_VALID (false, void, 1 & RE ())
140 CHECK_VALID (false, void, 1 ^ RE ())
141
142 /* operator OP (enum_flags, int) */
143
144 CHECK_VALID (false, void, EF () | 1)
145 CHECK_VALID (false, void, EF () & 1)
146 CHECK_VALID (false, void, EF () ^ 1)
147
148 /* operator OP (int, enum_flags) */
149
150 CHECK_VALID (false, void, 1 | EF ())
151 CHECK_VALID (false, void, 1 & EF ())
152 CHECK_VALID (false, void, 1 ^ EF ())
153
154 /* operator OP (raw_enum, raw_enum) */
155
156 CHECK_VALID (false, void, RE () | RE2 ())
157 CHECK_VALID (false, void, RE () & RE2 ())
158 CHECK_VALID (false, void, RE () ^ RE2 ())
159 CHECK_VALID (true,  RE,   RE () | RE ())
160 CHECK_VALID (true,  RE,   RE () & RE ())
161 CHECK_VALID (true,  RE,   RE () ^ RE ())
162
163 /* operator OP (enum_flags, raw_enum) */
164
165 CHECK_VALID (false, void, EF () | RE2 ())
166 CHECK_VALID (false, void, EF () & RE2 ())
167 CHECK_VALID (false, void, EF () ^ RE2 ())
168 CHECK_VALID (true,  EF,   EF () | RE ())
169 CHECK_VALID (true,  EF,   EF () & RE ())
170 CHECK_VALID (true,  EF,   EF () ^ RE ())
171
172 /* operator OP= (raw_enum, raw_enum), rvalue ref on the lhs. */
173
174 CHECK_VALID (false, void, RE () |= RE2 ())
175 CHECK_VALID (false, void, RE () &= RE2 ())
176 CHECK_VALID (false, void, RE () ^= RE2 ())
177 CHECK_VALID (false, void, RE () |= RE ())
178 CHECK_VALID (false, void, RE () &= RE ())
179 CHECK_VALID (false, void, RE () ^= RE ())
180
181 /* operator OP= (raw_enum, raw_enum), lvalue ref on the lhs. */
182
183 CHECK_VALID (false, void, re |= RE2 ())
184 CHECK_VALID (false, void, re &= RE2 ())
185 CHECK_VALID (false, void, re ^= RE2 ())
186 CHECK_VALID (true,  RE&,  re |= RE ())
187 CHECK_VALID (true,  RE&,  re &= RE ())
188 CHECK_VALID (true,  RE&,  re ^= RE ())
189
190 /* operator OP= (enum_flags, raw_enum), rvalue ref on the lhs.  */
191
192 CHECK_VALID (false, void, EF () |= RE2 ())
193 CHECK_VALID (false, void, EF () &= RE2 ())
194 CHECK_VALID (false, void, EF () ^= RE2 ())
195 CHECK_VALID (false, void, EF () |= RE ())
196 CHECK_VALID (false, void, EF () &= RE ())
197 CHECK_VALID (false, void, EF () ^= RE ())
198
199 /* operator OP= (enum_flags, raw_enum), lvalue ref on the lhs.  */
200
201 CHECK_VALID (false, void, ef |= RE2 ())
202 CHECK_VALID (false, void, ef &= RE2 ())
203 CHECK_VALID (false, void, ef ^= RE2 ())
204 CHECK_VALID (true,  EF&,  ef |= EF ())
205 CHECK_VALID (true,  EF&,  ef &= EF ())
206 CHECK_VALID (true,  EF&,  ef ^= EF ())
207
208 /* operator OP= (enum_flags, enum_flags), rvalue ref on the lhs.  */
209
210 CHECK_VALID (false, void, EF () |= EF2 ())
211 CHECK_VALID (false, void, EF () &= EF2 ())
212 CHECK_VALID (false, void, EF () ^= EF2 ())
213 CHECK_VALID (false, void, EF () |= EF ())
214 CHECK_VALID (false, void, EF () &= EF ())
215 CHECK_VALID (false, void, EF () ^= EF ())
216
217 /* operator OP= (enum_flags, enum_flags), lvalue ref on the lhs.  */
218
219 CHECK_VALID (false, void, ef |= EF2 ())
220 CHECK_VALID (false, void, ef &= EF2 ())
221 CHECK_VALID (false, void, ef ^= EF2 ())
222 CHECK_VALID (true,  EF&,  ef |= EF ())
223 CHECK_VALID (true,  EF&,  ef &= EF ())
224 CHECK_VALID (true,  EF&,  ef ^= EF ())
225
226 /* operator~ (raw_enum) */
227
228 CHECK_VALID (false,  void,   ~RE ())
229 CHECK_VALID (true,   URE,    ~URE ())
230
231 /* operator~ (enum_flags) */
232
233 CHECK_VALID (false,  void,   ~EF ())
234 CHECK_VALID (true,   UEF,    ~UEF ())
235
236 /* Check ternary operator.  This exercises implicit conversions.  */
237
238 CHECK_VALID (true,  EF,   true ? EF () : RE ())
239 CHECK_VALID (true,  EF,   true ? RE () : EF ())
240
241 /* These are valid, but it's not a big deal since you won't be able to
242    assign the resulting integer to an enum or an enum_flags without a
243    cast.
244
245    The latter two tests are disabled on older GCCs because they
246    incorrectly fail with gcc 4.8 and 4.9 at least.  Running the test
247    outside a SFINAE context shows:
248
249     invalid user-defined conversion from ‘EF’ to ‘RE2’
250
251    They've been confirmed to compile/pass with gcc 5.3, gcc 7.1 and
252    clang 3.7.  */
253
254 CHECK_VALID (true,  int,  true ? EF () : EF2 ())
255 CHECK_VALID (true,  int,  true ? EF2 () : EF ())
256 #if GCC_VERSION >= 5003 || defined __clang__
257 CHECK_VALID (true,  int,  true ? EF () : RE2 ())
258 CHECK_VALID (true,  int,  true ? RE2 () : EF ())
259 #endif
260
261 /* Same, but with an unsigned enum.  */
262
263 typedef unsigned int uns;
264
265 CHECK_VALID (true,  uns,  true ? EF () : UEF ())
266 CHECK_VALID (true,  uns,  true ? UEF () : EF ())
267 #if GCC_VERSION >= 5003 || defined __clang__
268 CHECK_VALID (true,  uns,  true ? EF () : URE ())
269 CHECK_VALID (true,  uns,  true ? URE () : EF ())
270 #endif
271
272 /* Unfortunately this can't work due to the way C++ computes the
273    return type of the ternary conditional operator.  int isn't
274    implicitly convertible to the raw enum type, so the type of the
275    expression is int.  And then int is not implicitly convertible to
276    enum_flags.
277
278    GCC 4.8 fails to compile this test with:
279      error: operands to ?: have different types ‘enum_flags<RE>’ and ‘int’
280    Confirmed to work with gcc 4.9, 5.3 and clang 3.7.
281 */
282 #if GCC_VERSION >= 4009 || defined __clang__
283 CHECK_VALID (false, void, true ? EF () : 0)
284 CHECK_VALID (false, void, true ? 0 : EF ())
285 #endif
286
287 /* Check that the ++/--/<</>>/<<=/>>= operators are deleted.  */
288
289 CHECK_VALID (false, void, RE ()++)
290 CHECK_VALID (false, void, ++RE ())
291 CHECK_VALID (false, void, --RE ())
292 CHECK_VALID (false, void, RE ()--)
293
294 CHECK_VALID (false, void, RE () << 1)
295 CHECK_VALID (false, void, RE () >> 1)
296 CHECK_VALID (false, void, EF () << 1)
297 CHECK_VALID (false, void, EF () >> 1)
298
299 CHECK_VALID (false, void, RE () <<= 1)
300 CHECK_VALID (false, void, RE () >>= 1)
301 CHECK_VALID (false, void, EF () <<= 1)
302 CHECK_VALID (false, void, EF () >>= 1)
303
304 /* Test comparison operators.  */
305
306 CHECK_VALID (false, void, EF () == EF2 ())
307 CHECK_VALID (false, void, EF () == RE2 ())
308 CHECK_VALID (false, void, RE () == EF2 ())
309
310 CHECK_VALID (true,  bool, EF (RE (1)) == EF (RE (1)))
311 CHECK_VALID (true,  bool, EF (RE (1)) == RE (1))
312 CHECK_VALID (true,  bool, RE (1)      == EF (RE (1)))
313
314 CHECK_VALID (false, void, EF () != EF2 ())
315 CHECK_VALID (false, void, EF () != RE2 ())
316 CHECK_VALID (false, void, RE () != EF2 ())
317
318 /* Disable -Wenum-compare due to:
319
320    Clang:
321
322     "error: comparison of two values with different enumeration types
323     [-Werror,-Wenum-compare]"
324
325    GCC:
326
327     "error: comparison between ‘enum selftests::enum_flags_tests::RE’
328      and ‘enum selftests::enum_flags_tests::RE2’
329      [-Werror=enum-compare]"
330
331    Not a big deal since misuses like these in GDB will be caught by
332    -Werror anyway.  This check is here mainly for completeness.  */
333 #if defined __GNUC__
334 # pragma GCC diagnostic push
335 # pragma GCC diagnostic ignored "-Wenum-compare"
336 #endif
337 CHECK_VALID (true,  bool, RE () == RE2 ())
338 CHECK_VALID (true,  bool, RE () != RE2 ())
339 #if defined __GNUC__
340 # pragma GCC diagnostic pop
341 #endif
342
343 CHECK_VALID (true,  bool, EF (RE (1)) != EF (RE (2)))
344 CHECK_VALID (true,  bool, EF (RE (1)) != RE (2))
345 CHECK_VALID (true,  bool, RE (1)      != EF (RE (2)))
346
347 CHECK_VALID (true,  bool, EF () == 0)
348
349 /* Check we didn't disable/delete comparison between non-flags enums
350    and unrelated types by mistake.  */
351 CHECK_VALID (true,  bool, NF (1) == NF (1))
352 CHECK_VALID (true,  bool, NF (1) == int (1))
353 CHECK_VALID (true,  bool, NF (1) == char (1))
354
355 /* -------------------------------------------------------------------- */
356
357 /* Follows misc tests that exercise the API.  Some are compile time,
358    when possible, others are run time.  */
359
360 enum test_flag
361   {
362     FLAG1 = 1 << 1,
363     FLAG2 = 1 << 2,
364     FLAG3 = 1 << 3,
365   };
366
367 enum test_uflag : unsigned
368   {
369     UFLAG1 = 1 << 1,
370     UFLAG2 = 1 << 2,
371     UFLAG3 = 1 << 3,
372   };
373
374 DEF_ENUM_FLAGS_TYPE (test_flag, test_flags);
375 DEF_ENUM_FLAGS_TYPE (test_uflag, test_uflags);
376
377 static void
378 self_test ()
379 {
380   /* Check that default construction works.  */
381   {
382     constexpr test_flags f;
383
384     gdb_static_assert (f == 0);
385   }
386
387   /* Check that assignment from zero works.  */
388   {
389     test_flags f (FLAG1);
390
391     SELF_CHECK (f == FLAG1);
392
393     f = 0;
394
395     SELF_CHECK (f == 0);
396   }
397
398   /* Check that construction from zero works.  */
399   {
400     constexpr test_flags zero1 = 0;
401     constexpr test_flags zero2 (0);
402     constexpr test_flags zero3 {0};
403     constexpr test_flags zero4 = {0};
404
405     gdb_static_assert (zero1 == 0);
406     gdb_static_assert (zero2 == 0);
407     gdb_static_assert (zero3 == 0);
408     gdb_static_assert (zero4 == 0);
409   }
410
411   /* Check construction from enum value.  */
412   {
413     gdb_static_assert (test_flags (FLAG1) == FLAG1);
414     gdb_static_assert (test_flags (FLAG2) != FLAG1);
415   }
416
417   /* Check copy/assignment.  */
418   {
419     constexpr test_flags src = FLAG1;
420
421     constexpr test_flags f1 = src;
422     constexpr test_flags f2 (src);
423     constexpr test_flags f3 {src};
424     constexpr test_flags f4 = {src};
425
426     gdb_static_assert (f1 == FLAG1);
427     gdb_static_assert (f2 == FLAG1);
428     gdb_static_assert (f3 == FLAG1);
429     gdb_static_assert (f4 == FLAG1);
430   }
431
432   /* Check moving.  */
433   {
434     test_flags src = FLAG1;
435     test_flags dst = 0;
436
437     dst = std::move (src);
438     SELF_CHECK (dst == FLAG1);
439   }
440
441   /* Check construction from an 'or' of multiple bits.  For this to
442      work, operator| must be overridden to return an enum type.  The
443      builtin version would return int instead and then the conversion
444      to test_flags would fail.  */
445   {
446     constexpr test_flags f = FLAG1 | FLAG2;
447     gdb_static_assert (f == (FLAG1 | FLAG2));
448   }
449
450   /* Similarly, check that "FLAG1 | FLAG2" on the rhs of an assignment
451      operator works.  */
452   {
453     test_flags f = 0;
454     f |= FLAG1 | FLAG2;
455     SELF_CHECK (f == (FLAG1 | FLAG2));
456
457     f &= FLAG1 | FLAG2;
458     SELF_CHECK (f == (FLAG1 | FLAG2));
459
460     f ^= FLAG1 | FLAG2;
461     SELF_CHECK (f == 0);
462   }
463
464   /* Check explicit conversion to int works.  */
465   {
466     constexpr int some_bits (FLAG1 | FLAG2);
467
468     /* And comparison with int works too.  */
469     gdb_static_assert (some_bits == (FLAG1 | FLAG2));
470     gdb_static_assert (some_bits == test_flags (FLAG1 | FLAG2));
471   }
472
473   /* Check operator| and operator|=.  Particularly interesting is
474      making sure that putting the enum value on the lhs side of the
475      expression works (FLAG | f).  */
476   {
477     test_flags f = FLAG1;
478     f |= FLAG2;
479     SELF_CHECK (f == (FLAG1 | FLAG2));
480   }
481   {
482     test_flags f = FLAG1;
483     f = f | FLAG2;
484     SELF_CHECK (f == (FLAG1 | FLAG2));
485   }
486   {
487     test_flags f = FLAG1;
488     f = FLAG2 | f;
489     SELF_CHECK (f == (FLAG1 | FLAG2));
490   }
491
492   /* Check the &/&= operators.  */
493   {
494     test_flags f = FLAG1 & FLAG2;
495     SELF_CHECK (f == 0);
496
497     f = FLAG1 | FLAG2;
498     f &= FLAG2;
499     SELF_CHECK (f == FLAG2);
500
501     f = FLAG1 | FLAG2;
502     f = f & FLAG2;
503     SELF_CHECK (f == FLAG2);
504
505     f = FLAG1 | FLAG2;
506     f = FLAG2 & f;
507     SELF_CHECK (f == FLAG2);
508   }
509
510   /* Check the ^/^= operators.  */
511   {
512     constexpr test_flags f = FLAG1 ^ FLAG2;
513     gdb_static_assert (f == (FLAG1 ^ FLAG2));
514   }
515
516   {
517     test_flags f = FLAG1 ^ FLAG2;
518     f ^= FLAG3;
519     SELF_CHECK (f == (FLAG1 | FLAG2 | FLAG3));
520     f = f ^ FLAG3;
521     SELF_CHECK (f == (FLAG1 | FLAG2));
522     f = FLAG3 ^ f;
523     SELF_CHECK (f == (FLAG1 | FLAG2 | FLAG3));
524   }
525
526   /* Check operator~.  Note this only compiles with unsigned
527      flags.  */
528   {
529     constexpr test_uflags f1 = ~UFLAG1;
530     constexpr test_uflags f2 = ~f1;
531     gdb_static_assert (f2 == UFLAG1);
532   }
533
534   /* Check the ternary operator.  */
535
536   {
537     /* raw enum, raw enum */
538     constexpr test_flags f1 = true ? FLAG1 : FLAG2;
539     gdb_static_assert (f1 == FLAG1);
540     constexpr test_flags f2 = false ? FLAG1 : FLAG2;
541     gdb_static_assert (f2 == FLAG2);
542   }
543
544   {
545     /* enum flags, raw enum */
546     constexpr test_flags src = FLAG1;
547     constexpr test_flags f1 = true ? src : FLAG2;
548     gdb_static_assert (f1 == FLAG1);
549     constexpr test_flags f2 = false ? src : FLAG2;
550     gdb_static_assert (f2 == FLAG2);
551   }
552
553   {
554     /* enum flags, enum flags */
555     constexpr test_flags src1 = FLAG1;
556     constexpr test_flags src2 = FLAG2;
557     constexpr test_flags f1 = true ? src1 : src2;
558     gdb_static_assert (f1 == src1);
559     constexpr test_flags f2 = false ? src1 : src2;
560     gdb_static_assert (f2 == src2);
561   }
562
563   /* Check that we can use flags in switch expressions (requires
564      unambiguous conversion to integer).  Also check that we can use
565      operator| in switch cases, where only constants are allowed.
566      This should work because operator| is constexpr.  */
567   {
568     test_flags f = FLAG1 | FLAG2;
569     bool ok = false;
570
571     switch (f)
572       {
573       case FLAG1:
574         break;
575       case FLAG2:
576         break;
577       case FLAG1 | FLAG2:
578         ok = true;
579         break;
580       }
581
582     SELF_CHECK (ok);
583   }
584 }
585
586 } /* namespace enum_flags_tests */
587 } /* namespace selftests */
588
589 void _initialize_enum_flags_selftests ();
590
591 void
592 _initialize_enum_flags_selftests ()
593 {
594   selftests::register_test ("enum-flags",
595                             selftests::enum_flags_tests::self_test);
596 }
This page took 0.056028 seconds and 4 git commands to generate.