external/bsd/atf/dist/tools/config_test.cpp

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2007 The NetBSD Foundation, Inc.
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 // 1. Redistributions of source code must retain the above copyright
  11 //    notice, this list of conditions and the following disclaimer.
  12 // 2. Redistributions in binary form must reproduce the above copyright
  13 //    notice, this list of conditions and the following disclaimer in the
  14 //    documentation and/or other materials provided with the distribution.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 //
  29
  30 #include <cstring>
  31 #include <iostream>
  32
  33 #include <atf-c++.hpp>
  34
  35 #include "config.hpp"
  36 #include "env.hpp"
  37 #include "exceptions.hpp"
  38
  39 static const char *test_value = "env-value";
  40
  41 static struct varnames {
  42     const char *lc;
  43     const char *uc;
  44     bool can_be_empty;
  45 } all_vars[] = {
  46     { "atf_arch",           "ATF_ARCH",           false },
  47     { "atf_build_cc",       "ATF_BUILD_CC",       false },
  48     { "atf_build_cflags",   "ATF_BUILD_CFLAGS",   true  },
  49     { "atf_build_cpp",      "ATF_BUILD_CPP",      false },
  50     { "atf_build_cppflags", "ATF_BUILD_CPPFLAGS", true  },
  51     { "atf_build_cxx",      "ATF_BUILD_CXX",      false },
  52     { "atf_build_cxxflags", "ATF_BUILD_CXXFLAGS", true  },
  53     { "atf_confdir",        "ATF_CONFDIR",        false },
  54     { "atf_includedir",     "ATF_INCLUDEDIR",     false },
  55     { "atf_libdir",         "ATF_LIBDIR",         false },
  56     { "atf_libexecdir",     "ATF_LIBEXECDIR",     false },
  57     { "atf_machine",        "ATF_MACHINE",        false },
  58     { "atf_pkgdatadir",     "ATF_PKGDATADIR",     false },
  59     { "atf_shell",          "ATF_SHELL",          false },
  60     { "atf_workdir",        "ATF_WORKDIR",        false },
  61     { NULL,                 NULL,                 false }
  62 };
  63
  64 // ------------------------------------------------------------------------
  65 // Auxiliary functions.
  66 // ------------------------------------------------------------------------
  67
  68 namespace tools {
  69     namespace config {
  70         void __reinit(void);
  71     }
  72 }
  73
  74 static
  75 void
  76 set_env_var(const char* name, const char* val)
  77 {
  78     try {
  79         tools::env::set(name, val);
  80     } catch (const tools::system_error&) {
  81         ATF_FAIL(std::string("set_env_var(") + name + ", " + val +
  82                  ") failed");
  83     }
  84 }
  85
  86 static
  87 void
  88 unset_env_var(const char* name)
  89 {
  90     try {
  91         tools::env::unset(name);
  92     } catch (const tools::system_error&) {
  93         ATF_FAIL(std::string("unset_env_var(") + name + ") failed");
  94     }
  95 }
  96
  97 static
  98 size_t
  99 all_vars_count(void)
 100 {
 101     size_t count = 0;
 102     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 103         count++;
 104     return count;
 105 }
 106
 107 static
 108 void
 109 unset_all(void)
 110 {
 111     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 112         unset_env_var(v->uc);
 113 }
 114
 115 static
 116 void
 117 compare_one(const char* var, const char* expvalue)
 118 {
 119     std::cout << "Checking that " << var << " is set to " << expvalue << "\n";
 120
 121     for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
 122         if (std::strcmp(v->lc, var) == 0)
 123             ATF_REQUIRE_EQ(tools::config::get(v->lc), test_value);
 124         else
 125             ATF_REQUIRE(tools::config::get(v->lc) != test_value);
 126     }
 127 }
 128
 129 // ------------------------------------------------------------------------
 130 // Test cases for the free functions.
 131 // ------------------------------------------------------------------------
 132
 133 ATF_TEST_CASE(get);
 134 ATF_TEST_CASE_HEAD(get)
 135 {
 136     set_md_var("descr", "Tests the config::get function");
 137 }
 138 ATF_TEST_CASE_BODY(get)
 139 {
 140     // Unset all known environment variables and make sure the built-in
 141     // values do not match the bogus value we will use for testing.
 142     unset_all();
 143     tools::config::__reinit();
 144     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 145         ATF_REQUIRE(tools::config::get(v->lc) != test_value);
 146
 147     // Test the behavior of empty values.
 148     for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
 149         unset_all();
 150         if (!tools::config::get(v->lc).empty()) {
 151             set_env_var(v->uc, "");
 152             tools::config::__reinit();
 153             if (v->can_be_empty)
 154                 ATF_REQUIRE(tools::config::get(v->lc).empty());
 155             else
 156                 ATF_REQUIRE(!tools::config::get(v->lc).empty());
 157         }
 158     }
 159
 160     // Check if the ATF_ARCH variable is recognized.
 161     for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
 162         unset_all();
 163         set_env_var(v->uc, test_value);
 164         tools::config::__reinit();
 165         compare_one(v->lc, test_value);
 166     }
 167 }
 168
 169 ATF_TEST_CASE(get_all);
 170 ATF_TEST_CASE_HEAD(get_all)
 171 {
 172     set_md_var("descr", "Tests the config::get_all function");
 173 }
 174 ATF_TEST_CASE_BODY(get_all)
 175 {
 176     tools::config::__reinit();
 177
 178     // Check that the valid variables, and only those, are returned.
 179     std::map< std::string, std::string > vars = tools::config::get_all();
 180     ATF_REQUIRE_EQ(vars.size(), all_vars_count());
 181     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 182         ATF_REQUIRE(vars.find(v->lc) != vars.end());
 183 }
 184
 185 ATF_TEST_CASE(has);
 186 ATF_TEST_CASE_HEAD(has)
 187 {
 188     set_md_var("descr", "Tests the config::has function");
 189 }
 190 ATF_TEST_CASE_BODY(has)
 191 {
 192     tools::config::__reinit();
 193
 194     // Check for all the variables that must exist.
 195     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 196         ATF_REQUIRE(tools::config::has(v->lc));
 197
 198     // Same as above, but using uppercase (which is incorrect).
 199     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 200         ATF_REQUIRE(!tools::config::has(v->uc));
 201
 202     // Check for some other variables that cannot exist.
 203     ATF_REQUIRE(!tools::config::has("foo"));
 204     ATF_REQUIRE(!tools::config::has("BAR"));
 205     ATF_REQUIRE(!tools::config::has("atf_foo"));
 206     ATF_REQUIRE(!tools::config::has("ATF_BAR"));
 207     ATF_REQUIRE(!tools::config::has("atf_shel"));
 208     ATF_REQUIRE(!tools::config::has("atf_shells"));
 209 }
 210
 211 // ------------------------------------------------------------------------
 212 // Main.
 213 // ------------------------------------------------------------------------
 214
 215 ATF_INIT_TEST_CASES(tcs)
 216 {
 217     // Add the test cases for the free functions.
 218     ATF_ADD_TEST_CASE(tcs, has);
 219     ATF_ADD_TEST_CASE(tcs, get);
 220     ATF_ADD_TEST_CASE(tcs, get_all);
 221 }