diff options
Diffstat (limited to 'gdb/unittests/environ-selftests.c')
| -rw-r--r-- | gdb/unittests/environ-selftests.c | 247 |
1 files changed, 197 insertions, 50 deletions
diff --git a/gdb/unittests/environ-selftests.c b/gdb/unittests/environ-selftests.c index 28b16f8..f770901 100644 --- a/gdb/unittests/environ-selftests.c +++ b/gdb/unittests/environ-selftests.c @@ -22,64 +22,60 @@ #include "common/environ.h" #include "common/diagnostics.h" +static const char gdb_selftest_env_var[] = "GDB_SELFTEST_ENVIRON"; + +static bool +set_contains (const std::set<std::string> &set, std::string key) +{ + return set.find (key) != set.end (); +} + namespace selftests { namespace gdb_environ_tests { +/* Test if the vector is initialized in a correct way. */ + static void -run_tests () +test_vector_initialization () { - /* Set a test environment variable. This will be unset at the end - of this function. */ - if (setenv ("GDB_SELFTEST_ENVIRON", "1", 1) != 0) - error (_("Could not set environment variable for testing.")); - gdb_environ env; /* When the vector is initialized, there should always be one NULL element in it. */ SELF_CHECK (env.envp ()[0] == NULL); + SELF_CHECK (env.user_set_env ().size () == 0); + SELF_CHECK (env.user_unset_env ().size () == 0); /* Make sure that there is no other element. */ SELF_CHECK (env.get ("PWD") == NULL); +} - /* Check if unset followed by a set in an empty vector works. */ - env.set ("PWD", "test"); - SELF_CHECK (strcmp (env.get ("PWD"), "test") == 0); - /* The second element must be NULL. */ - SELF_CHECK (env.envp ()[1] == NULL); - env.unset ("PWD"); - SELF_CHECK (env.envp ()[0] == NULL); +/* Test initialization using the host's environ. */ +static void +test_init_from_host_environ () +{ /* Initialize the environment vector using the host's environ. */ - env = gdb_environ::from_host_environ (); + gdb_environ env = gdb_environ::from_host_environ (); + + /* The user-set and user-unset lists must be empty. */ + SELF_CHECK (env.user_set_env ().size () == 0); + SELF_CHECK (env.user_unset_env ().size () == 0); /* Our test environment variable should be present at the vector. */ - SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "1") == 0); - - /* Set our test variable to another value. */ - env.set ("GDB_SELFTEST_ENVIRON", "test"); - SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "test") == 0); - - /* And unset our test variable. The variable still exists in the - host's environment, but doesn't exist in our vector. */ - env.unset ("GDB_SELFTEST_ENVIRON"); - SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") == NULL); - - /* Re-set the test variable. */ - env.set ("GDB_SELFTEST_ENVIRON", "1"); - SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "1") == 0); + SELF_CHECK (strcmp (env.get (gdb_selftest_env_var), "1") == 0); +} - /* When we clear our environ vector, there should be only one - element on it (NULL), and we shouldn't be able to get our test - variable. */ - env.clear (); - SELF_CHECK (env.envp ()[0] == NULL); - SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") == NULL); +/* Test reinitialization using the host's environ. */ +static void +test_reinit_from_host_environ () +{ /* Reinitialize our environ vector using the host environ. We should be able to see one (and only one) instance of the test variable. */ + gdb_environ env = gdb_environ::from_host_environ (); env = gdb_environ::from_host_environ (); char **envp = env.envp (); int num_found = 0; @@ -88,15 +84,23 @@ run_tests () if (strcmp (envp[i], "GDB_SELFTEST_ENVIRON=1") == 0) ++num_found; SELF_CHECK (num_found == 1); +} - /* Get rid of our test variable. */ - unsetenv ("GDB_SELFTEST_ENVIRON"); +/* Test the case when we set a variable A, then set a variable B, + then unset A, and make sure that we cannot find A in the environ + vector, but can still find B. */ + +static void +test_set_A_unset_B_unset_A_cannot_find_A_can_find_B () +{ + gdb_environ env; - /* Test the case when we set a variable A, then set a variable B, - then unset A, and make sure that we cannot find A in the environ - vector, but can still find B. */ env.set ("GDB_SELFTEST_ENVIRON_1", "aaa"); SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_1"), "aaa") == 0); + /* User-set environ var list must contain one element. */ + SELF_CHECK (env.user_set_env ().size () == 1); + SELF_CHECK (set_contains (env.user_set_env (), + std::string ("GDB_SELFTEST_ENVIRON_1=aaa"))); env.set ("GDB_SELFTEST_ENVIRON_2", "bbb"); SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_2"), "bbb") == 0); @@ -105,38 +109,117 @@ run_tests () SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON_1") == NULL); SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_2"), "bbb") == 0); + /* The user-set environ var list must contain only one element + now. */ + SELF_CHECK (set_contains (env.user_set_env (), + std::string ("GDB_SELFTEST_ENVIRON_2=bbb"))); + SELF_CHECK (env.user_set_env ().size () == 1); +} + +/* Check if unset followed by a set in an empty vector works. */ + +static void +test_unset_set_empty_vector () +{ + gdb_environ env; + + env.set ("PWD", "test"); + SELF_CHECK (strcmp (env.get ("PWD"), "test") == 0); + SELF_CHECK (set_contains (env.user_set_env (), std::string ("PWD=test"))); + SELF_CHECK (env.user_unset_env ().size () == 0); + /* The second element must be NULL. */ + SELF_CHECK (env.envp ()[1] == NULL); + SELF_CHECK (env.user_set_env ().size () == 1); + env.unset ("PWD"); + SELF_CHECK (env.envp ()[0] == NULL); + SELF_CHECK (env.user_set_env ().size () == 0); + SELF_CHECK (env.user_unset_env ().size () == 1); + SELF_CHECK (set_contains (env.user_unset_env (), std::string ("PWD"))); +} + +/* When we clear our environ vector, there should be only one + element on it (NULL), and we shouldn't be able to get our test + variable. */ + +static void +test_vector_clear () +{ + gdb_environ env; + + env.set (gdb_selftest_env_var, "1"); + env.clear (); + SELF_CHECK (env.envp ()[0] == NULL); + SELF_CHECK (env.user_set_env ().size () == 0); + SELF_CHECK (env.user_unset_env ().size () == 0); + SELF_CHECK (env.get (gdb_selftest_env_var) == NULL); +} + +/* Test that after a std::move the moved-from object is left at a + valid state (i.e., its only element is NULL). */ + +static void +test_std_move () +{ + gdb_environ env; + gdb_environ env2; - /* Test that after a std::move the moved-from object is left at a - valid state (i.e., its only element is NULL). */ env.set ("A", "1"); SELF_CHECK (strcmp (env.get ("A"), "1") == 0); - gdb_environ env2; + SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1"))); + SELF_CHECK (env.user_set_env ().size () == 1); + env2 = std::move (env); SELF_CHECK (env.envp ()[0] == NULL); SELF_CHECK (strcmp (env2.get ("A"), "1") == 0); SELF_CHECK (env2.envp ()[1] == NULL); + SELF_CHECK (env.user_set_env ().size () == 0); + SELF_CHECK (set_contains (env2.user_set_env (), std::string ("A=1"))); + SELF_CHECK (env2.user_set_env ().size () == 1); env.set ("B", "2"); SELF_CHECK (strcmp (env.get ("B"), "2") == 0); SELF_CHECK (env.envp ()[1] == NULL); +} + +/* Test that the move constructor leaves everything at a valid + state. */ + +static void +test_move_constructor () +{ + gdb_environ env; - /* Test that the move constructor leaves everything at a valid - state. */ - env.clear (); env.set ("A", "1"); SELF_CHECK (strcmp (env.get ("A"), "1") == 0); - gdb_environ env3 = std::move (env); + SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1"))); + + gdb_environ env2 = std::move (env); SELF_CHECK (env.envp ()[0] == NULL); - SELF_CHECK (strcmp (env3.get ("A"), "1") == 0); - SELF_CHECK (env3.envp ()[1] == NULL); + SELF_CHECK (env.user_set_env ().size () == 0); + SELF_CHECK (strcmp (env2.get ("A"), "1") == 0); + SELF_CHECK (env2.envp ()[1] == NULL); + SELF_CHECK (set_contains (env2.user_set_env (), std::string ("A=1"))); + SELF_CHECK (env2.user_set_env ().size () == 1); + env.set ("B", "2"); SELF_CHECK (strcmp (env.get ("B"), "2") == 0); SELF_CHECK (env.envp ()[1] == NULL); + SELF_CHECK (set_contains (env.user_set_env (), std::string ("B=2"))); + SELF_CHECK (env.user_set_env ().size () == 1); +} + +/* Test that self-moving works. */ + +static void +test_self_move () +{ + gdb_environ env; /* Test self-move. */ - env.clear (); env.set ("A", "1"); SELF_CHECK (strcmp (env.get ("A"), "1") == 0); + SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1"))); + SELF_CHECK (env.user_set_env ().size () == 1); /* Some compilers warn about moving to self, but that's precisely what we want to test here, so turn this warning off. */ @@ -148,6 +231,69 @@ run_tests () SELF_CHECK (strcmp (env.get ("A"), "1") == 0); SELF_CHECK (strcmp (env.envp ()[0], "A=1") == 0); SELF_CHECK (env.envp ()[1] == NULL); + SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1"))); + SELF_CHECK (env.user_set_env ().size () == 1); +} + +/* Test if set/unset/reset works. */ + +static void +test_set_unset_reset () +{ + gdb_environ env = gdb_environ::from_host_environ (); + + /* Our test variable should already be present in the host's environment. */ + SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") != NULL); + + /* Set our test variable to another value. */ + env.set ("GDB_SELFTEST_ENVIRON", "test"); + SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "test") == 0); + SELF_CHECK (env.user_set_env ().size () == 1); + SELF_CHECK (env.user_unset_env ().size () == 0); + + /* And unset our test variable. The variable still exists in the + host's environment, but doesn't exist in our vector. */ + env.unset ("GDB_SELFTEST_ENVIRON"); + SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") == NULL); + SELF_CHECK (env.user_set_env ().size () == 0); + SELF_CHECK (env.user_unset_env ().size () == 1); + SELF_CHECK (set_contains (env.user_unset_env (), + std::string ("GDB_SELFTEST_ENVIRON"))); + + /* Re-set the test variable. */ + env.set ("GDB_SELFTEST_ENVIRON", "1"); + SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "1") == 0); +} + +static void +run_tests () +{ + /* Set a test environment variable. */ + if (setenv ("GDB_SELFTEST_ENVIRON", "1", 1) != 0) + error (_("Could not set environment variable for testing.")); + + test_vector_initialization (); + + test_unset_set_empty_vector (); + + test_init_from_host_environ (); + + test_set_unset_reset (); + + test_vector_clear (); + + test_reinit_from_host_environ (); + + /* Get rid of our test variable. We won't need it anymore. */ + unsetenv ("GDB_SELFTEST_ENVIRON"); + + test_set_A_unset_B_unset_A_cannot_find_A_can_find_B (); + + test_std_move (); + + test_move_constructor (); + + test_self_move (); } } /* namespace gdb_environ */ } /* namespace selftests */ @@ -155,5 +301,6 @@ run_tests () void _initialize_environ_selftests () { - register_self_test (selftests::gdb_environ_tests::run_tests); + selftests::register_test ("gdb_environ", + selftests::gdb_environ_tests::run_tests); } |