gdb/unittests/packed-selftests.c

   1 /* Self tests for packed for GDB, the GNU debugger.
   2
   3    Copyright (C) 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/selftest.h"
  22 #include "gdbsupport/packed.h"
  23
  24 namespace selftests {
  25 namespace packed_tests {
  26
  27 enum test_enum
  28 {
  29   TE_A = 1,
  30   TE_B = 2,
  31   TE_C = 3,
  32   TE_D = 4,
  33 };
  34
  35 gdb_static_assert (sizeof (packed<test_enum, 1>) == 1);
  36 gdb_static_assert (sizeof (packed<test_enum, 2>) == 2);
  37 gdb_static_assert (sizeof (packed<test_enum, 3>) == 3);
  38 gdb_static_assert (sizeof (packed<test_enum, 4>) == 4);
  39
  40 gdb_static_assert (alignof (packed<test_enum, 1>) == 1);
  41 gdb_static_assert (alignof (packed<test_enum, 2>) == 1);
  42 gdb_static_assert (alignof (packed<test_enum, 3>) == 1);
  43 gdb_static_assert (alignof (packed<test_enum, 4>) == 1);
  44
  45 /* Triviality checks.  */
  46 #define CHECK_TRAIT(TRAIT)                      \
  47   static_assert (std::TRAIT<packed<test_enum, 1>>::value, "")
  48
  49 #if HAVE_IS_TRIVIALLY_COPYABLE
  50
  51 CHECK_TRAIT (is_trivially_copyable);
  52 CHECK_TRAIT (is_trivially_copy_constructible);
  53 CHECK_TRAIT (is_trivially_move_constructible);
  54 CHECK_TRAIT (is_trivially_copy_assignable);
  55 CHECK_TRAIT (is_trivially_move_assignable);
  56
  57 #endif
  58
  59 #undef CHECK_TRAIT
  60
  61 /* Entry point.  */
  62
  63 static void
  64 run_tests ()
  65 {
  66   typedef packed<unsigned int, 2> packed_2;
  67
  68   packed_2 p1;
  69   packed_2 p2 (0x0102);
  70   p1 = 0x0102;
  71
  72   SELF_CHECK (p1 == p1);
  73   SELF_CHECK (p1 == p2);
  74   SELF_CHECK (p1 == 0x0102);
  75   SELF_CHECK (0x0102 == p1);
  76
  77   SELF_CHECK (p1 != 0);
  78   SELF_CHECK (0 != p1);
  79
  80   SELF_CHECK (p1 != 0x0103);
  81   SELF_CHECK (0x0103 != p1);
  82
  83   SELF_CHECK (p1 != 0x01020102);
  84   SELF_CHECK (0x01020102 != p1);
  85
  86   SELF_CHECK (p1 != 0x01020000);
  87   SELF_CHECK (0x01020000 != p1);
  88
  89   /* Check truncation.  */
  90   p1 = 0x030102;
  91   SELF_CHECK (p1 == 0x0102);
  92   SELF_CHECK (p1 != 0x030102);
  93
  94   /* Check that the custom std::atomic/packed/T relational operators
  95      work as intended.  No need for fully comprehensive tests, as all
  96      operators are defined in the same way, via a macro.  We just want
  97      to make sure that we can compare atomic-wrapped packed, with
  98      packed, and with the packed underlying type.  */
  99
 100   std::atomic<packed<unsigned int, 2>> atomic_packed_2 (0x0102);
 101
 102   SELF_CHECK (atomic_packed_2 == atomic_packed_2);
 103   SELF_CHECK (atomic_packed_2 == p1);
 104   SELF_CHECK (p1 == atomic_packed_2);
 105   SELF_CHECK (atomic_packed_2 == 0x0102u);
 106   SELF_CHECK (0x0102u == atomic_packed_2);
 107
 108   SELF_CHECK (atomic_packed_2 >= 0x0102u);
 109   SELF_CHECK (atomic_packed_2 <= 0x0102u);
 110   SELF_CHECK (atomic_packed_2 > 0u);
 111   SELF_CHECK (atomic_packed_2 < 0x0103u);
 112   SELF_CHECK (atomic_packed_2 >= 0u);
 113   SELF_CHECK (atomic_packed_2 <= 0x0102u);
 114   SELF_CHECK (!(atomic_packed_2 > 0x0102u));
 115   SELF_CHECK (!(atomic_packed_2 < 0x0102u));
 116
 117   /* Check std::atomic<packed> truncation behaves the same as without
 118      std::atomic.  */
 119   atomic_packed_2 = 0x030102;
 120   SELF_CHECK (atomic_packed_2 == 0x0102u);
 121   SELF_CHECK (atomic_packed_2 != 0x030102u);
 122 }
 123
 124 } /* namespace packed_tests */
 125 } /* namespace selftests */
 126
 127 void _initialize_packed_selftests ();
 128 void
 129 _initialize_packed_selftests ()
 130 {
 131   selftests::register_test ("packed", selftests::packed_tests::run_tests);
 132 }