gdb/unittests/packed-selftests.c

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