external/bsd/atf/dist/atf-c++/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 "config.hpp"
  34 #include "macros.hpp"
  35
  36 #include "detail/env.hpp"
  37 #include "detail/exceptions.hpp"
  38 #include "detail/test_helpers.hpp"
  39
  40 static const char *test_value = "env-value";
  41
  42 static struct varnames {
  43     const char *lc;
  44     const char *uc;
  45     bool can_be_empty;
  46 } all_vars[] = {
  47     { "atf_arch",           "ATF_ARCH",           false },
  48     { "atf_build_cc",       "ATF_BUILD_CC",       false },
  49     { "atf_build_cflags",   "ATF_BUILD_CFLAGS",   true  },
  50     { "atf_build_cpp",      "ATF_BUILD_CPP",      false },
  51     { "atf_build_cppflags", "ATF_BUILD_CPPFLAGS", true  },
  52     { "atf_build_cxx",      "ATF_BUILD_CXX",      false },
  53     { "atf_build_cxxflags", "ATF_BUILD_CXXFLAGS", true  },
  54     { "atf_confdir",        "ATF_CONFDIR",        false },
  55     { "atf_includedir",     "ATF_INCLUDEDIR",     false },
  56     { "atf_libdir",         "ATF_LIBDIR",         false },
  57     { "atf_libexecdir",     "ATF_LIBEXECDIR",     false },
  58     { "atf_machine",        "ATF_MACHINE",        false },
  59     { "atf_pkgdatadir",     "ATF_PKGDATADIR",     false },
  60     { "atf_shell",          "ATF_SHELL",          false },
  61     { "atf_workdir",        "ATF_WORKDIR",        false },
  62     { NULL,                 NULL,                 false }
  63 };
  64
  65 // ------------------------------------------------------------------------
  66 // Auxiliary functions.
  67 // ------------------------------------------------------------------------
  68
  69 namespace atf {
  70     namespace config {
  71         void __reinit(void);
  72     }
  73 }
  74
  75 static
  76 void
  77 set_env_var(const char* name, const char* val)
  78 {
  79     try {
  80         atf::env::set(name, val);
  81     } catch (const atf::system_error&) {
  82         ATF_FAIL(std::string("set_env_var(") + name + ", " + val +
  83                  ") failed");
  84     }
  85 }
  86
  87 static
  88 void
  89 unset_env_var(const char* name)
  90 {
  91     try {
  92         atf::env::unset(name);
  93     } catch (const atf::system_error&) {
  94         ATF_FAIL(std::string("unset_env_var(") + name + ") failed");
  95     }
  96 }
  97
  98 static
  99 size_t
 100 all_vars_count(void)
 101 {
 102     size_t count = 0;
 103     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 104         count++;
 105     return count;
 106 }
 107
 108 static
 109 void
 110 unset_all(void)
 111 {
 112     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 113         unset_env_var(v->uc);
 114 }
 115
 116 static
 117 void
 118 compare_one(const char* var, const char* expvalue)
 119 {
 120     std::cout << "Checking that " << var << " is set to " << expvalue << "\n";
 121
 122     for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
 123         if (std::strcmp(v->lc, var) == 0)
 124             ATF_REQUIRE_EQ(atf::config::get(v->lc), test_value);
 125         else
 126             ATF_REQUIRE(atf::config::get(v->lc) != test_value);
 127     }
 128 }
 129
 130 // ------------------------------------------------------------------------
 131 // Test cases for the free functions.
 132 // ------------------------------------------------------------------------
 133
 134 ATF_TEST_CASE(get);
 135 ATF_TEST_CASE_HEAD(get)
 136 {
 137     set_md_var("descr", "Tests the config::get function");
 138 }
 139 ATF_TEST_CASE_BODY(get)
 140 {
 141     // Unset all known environment variables and make sure the built-in
 142     // values do not match the bogus value we will use for testing.
 143     unset_all();
 144     atf::config::__reinit();
 145     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 146         ATF_REQUIRE(atf::config::get(v->lc) != test_value);
 147
 148     // Test the behavior of empty values.
 149     for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
 150         unset_all();
 151         if (!atf::config::get(v->lc).empty()) {
 152             set_env_var(v->uc, "");
 153             atf::config::__reinit();
 154             if (v->can_be_empty)
 155                 ATF_REQUIRE(atf::config::get(v->lc).empty());
 156             else
 157                 ATF_REQUIRE(!atf::config::get(v->lc).empty());
 158         }
 159     }
 160
 161     // Check if the ATF_ARCH variable is recognized.
 162     for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
 163         unset_all();
 164         set_env_var(v->uc, test_value);
 165         atf::config::__reinit();
 166         compare_one(v->lc, test_value);
 167     }
 168 }
 169
 170 ATF_TEST_CASE(get_all);
 171 ATF_TEST_CASE_HEAD(get_all)
 172 {
 173     set_md_var("descr", "Tests the config::get_all function");
 174 }
 175 ATF_TEST_CASE_BODY(get_all)
 176 {
 177     atf::config::__reinit();
 178
 179     // Check that the valid variables, and only those, are returned.
 180     std::map< std::string, std::string > vars = atf::config::get_all();
 181     ATF_REQUIRE_EQ(vars.size(), all_vars_count());
 182     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 183         ATF_REQUIRE(vars.find(v->lc) != vars.end());
 184 }
 185
 186 ATF_TEST_CASE(has);
 187 ATF_TEST_CASE_HEAD(has)
 188 {
 189     set_md_var("descr", "Tests the config::has function");
 190 }
 191 ATF_TEST_CASE_BODY(has)
 192 {
 193     atf::config::__reinit();
 194
 195     // Check for all the variables that must exist.
 196     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 197         ATF_REQUIRE(atf::config::has(v->lc));
 198
 199     // Same as above, but using uppercase (which is incorrect).
 200     for (const struct varnames* v = all_vars; v->lc != NULL; v++)
 201         ATF_REQUIRE(!atf::config::has(v->uc));
 202
 203     // Check for some other variables that cannot exist.
 204     ATF_REQUIRE(!atf::config::has("foo"));
 205     ATF_REQUIRE(!atf::config::has("BAR"));
 206     ATF_REQUIRE(!atf::config::has("atf_foo"));
 207     ATF_REQUIRE(!atf::config::has("ATF_BAR"));
 208     ATF_REQUIRE(!atf::config::has("atf_shel"));
 209     ATF_REQUIRE(!atf::config::has("atf_shells"));
 210 }
 211
 212 // ------------------------------------------------------------------------
 213 // Tests cases for the header file.
 214 // ------------------------------------------------------------------------
 215
 216 HEADER_TC(include, "atf-c++/config.hpp");
 217
 218 // ------------------------------------------------------------------------
 219 // Main.
 220 // ------------------------------------------------------------------------
 221
 222 ATF_INIT_TEST_CASES(tcs)
 223 {
 224     // Add the test cases for the free functions.
 225     ATF_ADD_TEST_CASE(tcs, has);
 226     ATF_ADD_TEST_CASE(tcs, get);
 227     ATF_ADD_TEST_CASE(tcs, get_all);
 228
 229     // Add the test cases for the header file.
 230     ATF_ADD_TEST_CASE(tcs, include);
 231 }