vendor/atf/atf-0.16

1 files changed, 231 insertions, 0 deletions

diff --git a/atf-c++/config_test.cpp b/atf-c++/config_test.cpp
new file mode 100644
index 000000000000..a3cd2bb511d4
--- /dev/null
+++ b/atf-c++/config_test.cpp
@@ -0,0 +1,231 @@
+//
+// Automated Testing Framework (atf)
+//
+// Copyright (c) 2007 The NetBSD Foundation, Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
+// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+#include <cstring>
+#include <iostream>
+
+#include "config.hpp"
+#include "macros.hpp"
+
+#include "detail/env.hpp"
+#include "detail/exceptions.hpp"
+#include "detail/test_helpers.hpp"
+
+static const char *test_value = "env-value";
+
+static struct varnames {
+    const char *lc;
+    const char *uc;
+    bool can_be_empty;
+} all_vars[] = {
+    { "atf_arch",           "ATF_ARCH",           false },
+    { "atf_build_cc",       "ATF_BUILD_CC",       false },
+    { "atf_build_cflags",   "ATF_BUILD_CFLAGS",   true  },
+    { "atf_build_cpp",      "ATF_BUILD_CPP",      false },
+    { "atf_build_cppflags", "ATF_BUILD_CPPFLAGS", true  },
+    { "atf_build_cxx",      "ATF_BUILD_CXX",      false },
+    { "atf_build_cxxflags", "ATF_BUILD_CXXFLAGS", true  },
+    { "atf_confdir",        "ATF_CONFDIR",        false },
+    { "atf_includedir",     "ATF_INCLUDEDIR",     false },
+    { "atf_libdir",         "ATF_LIBDIR",         false },
+    { "atf_libexecdir",     "ATF_LIBEXECDIR",     false },
+    { "atf_machine",        "ATF_MACHINE",        false },
+    { "atf_pkgdatadir",     "ATF_PKGDATADIR",     false },
+    { "atf_shell",          "ATF_SHELL",          false },
+    { "atf_workdir",        "ATF_WORKDIR",        false },
+    { NULL,                 NULL,                 false }
+};
+
+// ------------------------------------------------------------------------
+// Auxiliary functions.
+// ------------------------------------------------------------------------
+
+namespace atf {
+    namespace config {
+        void __reinit(void);
+    }
+}
+
+static
+void
+set_env_var(const char* name, const char* val)
+{
+    try {
+        atf::env::set(name, val);
+    } catch (const atf::system_error&) {
+        ATF_FAIL(std::string("set_env_var(") + name + ", " + val +
+                 ") failed");
+    }
+}
+
+static
+void
+unset_env_var(const char* name)
+{
+    try {
+        atf::env::unset(name);
+    } catch (const atf::system_error&) {
+        ATF_FAIL(std::string("unset_env_var(") + name + ") failed");
+    }
+}
+
+static
+size_t
+all_vars_count(void)
+{
+    size_t count = 0;
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++)
+        count++;
+    return count;
+}
+
+static
+void
+unset_all(void)
+{
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++)
+        unset_env_var(v->uc);
+}
+
+static
+void
+compare_one(const char* var, const char* expvalue)
+{
+    std::cout << "Checking that " << var << " is set to " << expvalue << "\n";
+
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
+        if (std::strcmp(v->lc, var) == 0)
+            ATF_REQUIRE_EQ(atf::config::get(v->lc), test_value);
+        else
+            ATF_REQUIRE(atf::config::get(v->lc) != test_value);
+    }
+}
+
+// ------------------------------------------------------------------------
+// Test cases for the free functions.
+// ------------------------------------------------------------------------
+
+ATF_TEST_CASE(get);
+ATF_TEST_CASE_HEAD(get)
+{
+    set_md_var("descr", "Tests the config::get function");
+}
+ATF_TEST_CASE_BODY(get)
+{
+    // Unset all known environment variables and make sure the built-in
+    // values do not match the bogus value we will use for testing.
+    unset_all();
+    atf::config::__reinit();
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++)
+        ATF_REQUIRE(atf::config::get(v->lc) != test_value);
+
+    // Test the behavior of empty values.
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
+        unset_all();
+        if (!atf::config::get(v->lc).empty()) {
+            set_env_var(v->uc, "");
+            atf::config::__reinit();
+            if (v->can_be_empty)
+                ATF_REQUIRE(atf::config::get(v->lc).empty());
+            else
+                ATF_REQUIRE(!atf::config::get(v->lc).empty());
+        }
+    }
+
+    // Check if the ATF_ARCH variable is recognized.
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++) {
+        unset_all();
+        set_env_var(v->uc, test_value);
+        atf::config::__reinit();
+        compare_one(v->lc, test_value);
+    }
+}
+
+ATF_TEST_CASE(get_all);
+ATF_TEST_CASE_HEAD(get_all)
+{
+    set_md_var("descr", "Tests the config::get_all function");
+}
+ATF_TEST_CASE_BODY(get_all)
+{
+    atf::config::__reinit();
+
+    // Check that the valid variables, and only those, are returned.
+    std::map< std::string, std::string > vars = atf::config::get_all();
+    ATF_REQUIRE_EQ(vars.size(), all_vars_count());
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++)
+        ATF_REQUIRE(vars.find(v->lc) != vars.end());
+}
+
+ATF_TEST_CASE(has);
+ATF_TEST_CASE_HEAD(has)
+{
+    set_md_var("descr", "Tests the config::has function");
+}
+ATF_TEST_CASE_BODY(has)
+{
+    atf::config::__reinit();
+
+    // Check for all the variables that must exist.
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++)
+        ATF_REQUIRE(atf::config::has(v->lc));
+
+    // Same as above, but using uppercase (which is incorrect).
+    for (const struct varnames* v = all_vars; v->lc != NULL; v++)
+        ATF_REQUIRE(!atf::config::has(v->uc));
+
+    // Check for some other variables that cannot exist.
+    ATF_REQUIRE(!atf::config::has("foo"));
+    ATF_REQUIRE(!atf::config::has("BAR"));
+    ATF_REQUIRE(!atf::config::has("atf_foo"));
+    ATF_REQUIRE(!atf::config::has("ATF_BAR"));
+    ATF_REQUIRE(!atf::config::has("atf_shel"));
+    ATF_REQUIRE(!atf::config::has("atf_shells"));
+}
+
+// ------------------------------------------------------------------------
+// Tests cases for the header file.
+// ------------------------------------------------------------------------
+
+HEADER_TC(include, "atf-c++/config.hpp");
+
+// ------------------------------------------------------------------------
+// Main.
+// ------------------------------------------------------------------------
+
+ATF_INIT_TEST_CASES(tcs)
+{
+    // Add the test cases for the free functions.
+    ATF_ADD_TEST_CASE(tcs, has);
+    ATF_ADD_TEST_CASE(tcs, get);
+    ATF_ADD_TEST_CASE(tcs, get_all);
+
+    // Add the test cases for the header file.
+    ATF_ADD_TEST_CASE(tcs, include);
+}