gdb/unittests/environ-selftests.c

   1 /* Self tests for gdb_environ for GDB, the GNU debugger.
   2
   3    Copyright (C) 2017-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/environ.h"
  22 #include "diagnostics.h"
  23
  24 static const char gdb_selftest_env_var[] = "GDB_SELFTEST_ENVIRON";
  25
  26 static bool
  27 set_contains (const std::set<std::string> &set, std::string key)
  28 {
  29   return set.find (key) != set.end ();
  30 }
  31
  32 namespace selftests {
  33 namespace gdb_environ_tests {
  34
  35 /* Test if the vector is initialized in a correct way.  */
  36
  37 static void
  38 test_vector_initialization ()
  39 {
  40   gdb_environ env;
  41
  42   /* When the vector is initialized, there should always be one NULL
  43      element in it.  */
  44   SELF_CHECK (env.envp ()[0] == NULL);
  45   SELF_CHECK (env.user_set_env ().size () == 0);
  46   SELF_CHECK (env.user_unset_env ().size () == 0);
  47
  48   /* Make sure that there is no other element.  */
  49   SELF_CHECK (env.get ("PWD") == NULL);
  50 }
  51
  52 /* Test initialization using the host's environ.  */
  53
  54 static void
  55 test_init_from_host_environ ()
  56 {
  57   /* Initialize the environment vector using the host's environ.  */
  58   gdb_environ env = gdb_environ::from_host_environ ();
  59
  60   /* The user-set and user-unset lists must be empty.  */
  61   SELF_CHECK (env.user_set_env ().size () == 0);
  62   SELF_CHECK (env.user_unset_env ().size () == 0);
  63
  64   /* Our test environment variable should be present at the
  65      vector.  */
  66   SELF_CHECK (strcmp (env.get (gdb_selftest_env_var), "1") == 0);
  67 }
  68
  69 /* Test reinitialization using the host's environ.  */
  70
  71 static void
  72 test_reinit_from_host_environ ()
  73 {
  74   /* Reinitialize our environ vector using the host environ.  We
  75      should be able to see one (and only one) instance of the test
  76      variable.  */
  77   gdb_environ env = gdb_environ::from_host_environ ();
  78   env = gdb_environ::from_host_environ ();
  79   char **envp = env.envp ();
  80   int num_found = 0;
  81
  82   for (size_t i = 0; envp[i] != NULL; ++i)
  83     if (strcmp (envp[i], "GDB_SELFTEST_ENVIRON=1") == 0)
  84       ++num_found;
  85   SELF_CHECK (num_found == 1);
  86 }
  87
  88 /* Test the case when we set a variable A, then set a variable B,
  89    then unset A, and make sure that we cannot find A in the environ
  90    vector, but can still find B.  */
  91
  92 static void
  93 test_set_A_unset_B_unset_A_cannot_find_A_can_find_B ()
  94 {
  95   gdb_environ env;
  96
  97   env.set ("GDB_SELFTEST_ENVIRON_1", "aaa");
  98   SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_1"), "aaa") == 0);
  99   /* User-set environ var list must contain one element.  */
 100   SELF_CHECK (env.user_set_env ().size () == 1);
 101   SELF_CHECK (set_contains (env.user_set_env (),
 102                             std::string ("GDB_SELFTEST_ENVIRON_1=aaa")));
 103
 104   env.set ("GDB_SELFTEST_ENVIRON_2", "bbb");
 105   SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_2"), "bbb") == 0);
 106
 107   env.unset ("GDB_SELFTEST_ENVIRON_1");
 108   SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON_1") == NULL);
 109   SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_2"), "bbb") == 0);
 110
 111   /* The user-set environ var list must contain only one element
 112      now.  */
 113   SELF_CHECK (set_contains (env.user_set_env (),
 114                             std::string ("GDB_SELFTEST_ENVIRON_2=bbb")));
 115   SELF_CHECK (env.user_set_env ().size () == 1);
 116 }
 117
 118 /* Check if unset followed by a set in an empty vector works.  */
 119
 120 static void
 121 test_unset_set_empty_vector ()
 122 {
 123   gdb_environ env;
 124
 125   env.set ("PWD", "test");
 126   SELF_CHECK (strcmp (env.get ("PWD"), "test") == 0);
 127   SELF_CHECK (set_contains (env.user_set_env (), std::string ("PWD=test")));
 128   SELF_CHECK (env.user_unset_env ().size () == 0);
 129   /* The second element must be NULL.  */
 130   SELF_CHECK (env.envp ()[1] == NULL);
 131   SELF_CHECK (env.user_set_env ().size () == 1);
 132   env.unset ("PWD");
 133   SELF_CHECK (env.envp ()[0] == NULL);
 134   SELF_CHECK (env.user_set_env ().size () == 0);
 135   SELF_CHECK (env.user_unset_env ().size () == 1);
 136   SELF_CHECK (set_contains (env.user_unset_env (), std::string ("PWD")));
 137 }
 138
 139 /* When we clear our environ vector, there should be only one
 140    element on it (NULL), and we shouldn't be able to get our test
 141    variable.  */
 142
 143 static void
 144 test_vector_clear ()
 145 {
 146   gdb_environ env;
 147
 148   env.set (gdb_selftest_env_var, "1");
 149
 150   env.clear ();
 151   SELF_CHECK (env.envp ()[0] == NULL);
 152   SELF_CHECK (env.user_set_env ().size () == 0);
 153   SELF_CHECK (env.user_unset_env ().size () == 0);
 154   SELF_CHECK (env.get (gdb_selftest_env_var) == NULL);
 155 }
 156
 157 /* Test that after a std::move the moved-from object is left at a
 158    valid state (i.e., its only element is NULL).  */
 159
 160 static void
 161 test_std_move ()
 162 {
 163   gdb_environ env;
 164   gdb_environ env2;
 165
 166   env.set ("A", "1");
 167   SELF_CHECK (strcmp (env.get ("A"), "1") == 0);
 168   SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1")));
 169   SELF_CHECK (env.user_set_env ().size () == 1);
 170
 171   env2 = std::move (env);
 172   SELF_CHECK (env.envp ()[0] == NULL);
 173   SELF_CHECK (strcmp (env2.get ("A"), "1") == 0);
 174   SELF_CHECK (env2.envp ()[1] == NULL);
 175   SELF_CHECK (env.user_set_env ().size () == 0);
 176   SELF_CHECK (set_contains (env2.user_set_env (), std::string ("A=1")));
 177   SELF_CHECK (env2.user_set_env ().size () == 1);
 178   env.set ("B", "2");
 179   SELF_CHECK (strcmp (env.get ("B"), "2") == 0);
 180   SELF_CHECK (env.envp ()[1] == NULL);
 181 }
 182
 183 /* Test that the move constructor leaves everything at a valid
 184    state.  */
 185
 186 static void
 187 test_move_constructor ()
 188 {
 189   gdb_environ env;
 190
 191   env.set ("A", "1");
 192   SELF_CHECK (strcmp (env.get ("A"), "1") == 0);
 193   SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1")));
 194
 195   gdb_environ env2 = std::move (env);
 196   SELF_CHECK (env.envp ()[0] == NULL);
 197   SELF_CHECK (env.user_set_env ().size () == 0);
 198   SELF_CHECK (strcmp (env2.get ("A"), "1") == 0);
 199   SELF_CHECK (env2.envp ()[1] == NULL);
 200   SELF_CHECK (set_contains (env2.user_set_env (), std::string ("A=1")));
 201   SELF_CHECK (env2.user_set_env ().size () == 1);
 202
 203   env.set ("B", "2");
 204   SELF_CHECK (strcmp (env.get ("B"), "2") == 0);
 205   SELF_CHECK (env.envp ()[1] == NULL);
 206   SELF_CHECK (set_contains (env.user_set_env (), std::string ("B=2")));
 207   SELF_CHECK (env.user_set_env ().size () == 1);
 208 }
 209
 210 /* Test that self-moving works.  */
 211
 212 static void
 213 test_self_move ()
 214 {
 215   gdb_environ env;
 216
 217   /* Test self-move.  */
 218   env.set ("A", "1");
 219   SELF_CHECK (strcmp (env.get ("A"), "1") == 0);
 220   SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1")));
 221   SELF_CHECK (env.user_set_env ().size () == 1);
 222
 223   /* Some compilers warn about moving to self, but that's precisely what we want
 224      to test here, so turn this warning off.  */
 225   DIAGNOSTIC_PUSH
 226   DIAGNOSTIC_IGNORE_SELF_MOVE
 227   env = std::move (env);
 228   DIAGNOSTIC_POP
 229
 230   SELF_CHECK (strcmp (env.get ("A"), "1") == 0);
 231   SELF_CHECK (strcmp (env.envp ()[0], "A=1") == 0);
 232   SELF_CHECK (env.envp ()[1] == NULL);
 233   SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1")));
 234   SELF_CHECK (env.user_set_env ().size () == 1);
 235 }
 236
 237 /* Test if set/unset/reset works.  */
 238
 239 static void
 240 test_set_unset_reset ()
 241 {
 242   gdb_environ env = gdb_environ::from_host_environ ();
 243
 244   /* Our test variable should already be present in the host's environment.  */
 245   SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") != NULL);
 246
 247   /* Set our test variable to another value.  */
 248   env.set ("GDB_SELFTEST_ENVIRON", "test");
 249   SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "test") == 0);
 250   SELF_CHECK (env.user_set_env ().size () == 1);
 251   SELF_CHECK (env.user_unset_env ().size () == 0);
 252
 253   /* And unset our test variable.  The variable still exists in the
 254      host's environment, but doesn't exist in our vector.  */
 255   env.unset ("GDB_SELFTEST_ENVIRON");
 256   SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") == NULL);
 257   SELF_CHECK (env.user_set_env ().size () == 0);
 258   SELF_CHECK (env.user_unset_env ().size () == 1);
 259   SELF_CHECK (set_contains (env.user_unset_env (),
 260                             std::string ("GDB_SELFTEST_ENVIRON")));
 261
 262   /* Re-set the test variable.  */
 263   env.set ("GDB_SELFTEST_ENVIRON", "1");
 264   SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "1") == 0);
 265 }
 266
 267 static void
 268 run_tests ()
 269 {
 270   /* Set a test environment variable.  */
 271   if (setenv ("GDB_SELFTEST_ENVIRON", "1", 1) != 0)
 272     error (_("Could not set environment variable for testing."));
 273
 274   test_vector_initialization ();
 275
 276   test_unset_set_empty_vector ();
 277
 278   test_init_from_host_environ ();
 279
 280   test_set_unset_reset ();
 281
 282   test_vector_clear ();
 283
 284   test_reinit_from_host_environ ();
 285
 286   /* Get rid of our test variable.  We won't need it anymore.  */
 287   unsetenv ("GDB_SELFTEST_ENVIRON");
 288
 289   test_set_A_unset_B_unset_A_cannot_find_A_can_find_B ();
 290
 291   test_std_move ();
 292
 293   test_move_constructor ();
 294
 295   test_self_move ();
 296 }
 297 } /* namespace gdb_environ */
 298 } /* namespace selftests */
 299
 300 void _initialize_environ_selftests ();
 301 void
 302 _initialize_environ_selftests ()
 303 {
 304   selftests::register_test ("gdb_environ",
 305                             selftests::gdb_environ_tests::run_tests);
 306 }