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, failed = 0;
  76   run_verbose_ = verbose;
  77
  78   for (const auto &test : all_selftests ())
  79     {
  80       bool run = false;
  81
  82       if (filters.empty ())
  83         run = true;
  84       else
  85         {
  86           for (const char *filter : filters)
  87             {
  88               if (test.name.find (filter) != std::string::npos)
  89                 run = true;
  90             }
  91         }
  92
  93       if (!run)
  94         continue;
  95
  96       try
  97         {
  98           debug_printf (_("Running selftest %s.\n"), test.name.c_str ());
  99           ++ran;
 100           test.test ();
 101         }
 102       catch (const gdb_exception_error &ex)
 103         {
 104           ++failed;
 105           debug_printf ("Self test failed: %s\n", ex.what ());
 106         }
 107
 108       reset ();
 109     }
 110
 111   debug_printf (_("Ran %d unit tests, %d failed\n"),
 112                 ran, failed);
 113 }
 114
 115 /* See selftest.h.  */
 116
 117 selftests_range
 118 all_selftests ()
 119 {
 120   /* Execute any function which might still want to register tests.  Once each
 121      function has been executed, clear lazy_generators to ensure that
 122      callback functions are only executed once.  */
 123   for (const auto &generator : lazy_generators)
 124     for (selftest &test : generator ())
 125       register_test (std::move (test.name), std::move (test.test));
 126   lazy_generators.clear ();
 127
 128   return selftests_range (tests.cbegin (), tests.cend ());
 129 }
 130
 131 } // namespace selftests