gdbsupport/selftest.cc

   1 /* GDB self-testing.
   2    Copyright (C) 2016-2023 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "common-defs.h"
  20 #include "common-exceptions.h"
  21 #include "common-debug.h"
  22 #include "selftest.h"
  23 #include <functional>
  24
  25 namespace selftests
  26 {
  27 /* All the tests that have been registered.  Using an std::set allows keeping
  28    the order of tests stable and easily looking up whether a test name
  29    exists.  */
  30
  31 static selftests_registry tests;
  32
  33 /* Set of callback functions used to register selftests after GDB is fully
  34    initialized.  */
  35
  36 static std::vector<selftests_generator> lazy_generators;
  37
  38 /* See selftest.h.  */
  39
  40 void
  41 register_test (const std::string &name,
  42                std::function<void(void)> function)
  43 {
  44   /* Check that no test with this name already exist.  */
  45   auto status = tests.emplace (name, std::move (function));
  46   if (!status.second)
  47     gdb_assert_not_reached ("Test already registered");
  48 }
  49
  50 /* See selftest.h.  */
  51
  52 void
  53 add_lazy_generator (selftests_generator generator)
  54 {
  55   lazy_generators.push_back (std::move (generator));
  56 }
  57
  58 /* See selftest.h.  */
  59
  60 static bool run_verbose_ = false;
  61
  62 /* See selftest.h.  */
  63
  64 bool
  65 run_verbose ()
  66 {
  67   return run_verbose_;
  68 }
  69
  70 /* See selftest.h.  */
  71
  72 void
  73 run_tests (gdb::array_view<const char *const> filters, bool verbose)
  74 {
  75   int ran = 0;
  76   run_verbose_ = verbose;
  77   std::vector<const char *> failed;
  78
  79   for (const auto &test : all_selftests ())
  80     {
  81       bool run = false;
  82
  83       if (filters.empty ())
  84         run = true;
  85       else
  86         {
  87           for (const char *filter : filters)
  88             {
  89               if (test.name.find (filter) != std::string::npos)
  90                 run = true;
  91             }
  92         }
  93
  94       if (!run)
  95         continue;
  96
  97       try
  98         {
  99           debug_printf (_("Running selftest %s.\n"), test.name.c_str ());
 100           ++ran;
 101           test.test ();
 102         }
 103       catch (const gdb_exception_error &ex)
 104         {
 105           debug_printf ("Self test failed: %s\n", ex.what ());
 106           failed.push_back (test.name.c_str ());
 107         }
 108
 109       reset ();
 110     }
 111
 112   if (!failed.empty ())
 113     {
 114       debug_printf ("\nFailures:\n");
 115
 116       for (const char *name : failed)
 117         debug_printf ("  %s\n", name);
 118
 119       debug_printf ("\n");
 120     }
 121
 122   debug_printf (_("Ran %d unit tests, %zu failed\n"),
 123                 ran, failed.size ());
 124 }
 125
 126 /* See selftest.h.  */
 127
 128 selftests_range
 129 all_selftests ()
 130 {
 131   /* Execute any function which might still want to register tests.  Once each
 132      function has been executed, clear lazy_generators to ensure that
 133      callback functions are only executed once.  */
 134   for (const auto &generator : lazy_generators)
 135     for (selftest &test : generator ())
 136       register_test (std::move (test.name), std::move (test.test));
 137   lazy_generators.clear ();
 138
 139   return selftests_range (tests.cbegin (), tests.cend ());
 140 }
 141
 142 } // namespace selftests