facter 3.9.6.cfacter.20180612 → 3.11.0.cfacter.20180319

data/ext/facter/leatherman/curl/tests/mock_curl.cc

@@ -106,6 +106,8 @@ CURLcode curl_easy_setopt(CURL *handle, CURLoption option, ...)
 {
     auto h = reinterpret_cast<curl_impl*>(handle);
     va_list vl;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wvarargs"
     va_start(vl, option);
 #pragma clang diagnostic pop
 

data/ext/facter/leatherman/curl/tests/request_test.cc

@@ -4,84 +4,82 @@
 #include <leatherman/curl/request.hpp>
 
 using namespace std;
+using namespace leatherman::curl;
 
-namespace leatherman { namespace curl {
+struct mock_client : client {
+    curl_handle const& get_handle() { return client::get_handle(); }
+};
 
-    struct mock_client : client {
-        curl_handle const& get_handle() { return client::get_handle(); }
-    };
+TEST_CASE("curl::request") {
+    request test_request {"http://valid.com"};
 
-    TEST_CASE("curl::request") {
-        request test_request {"http://valid.com"};
-
-        SECTION("Headers should be addable and retrievable from the request") {
-            test_request.add_header("header_name", "header_value");
-            auto header = test_request.header("header_name");
-            REQUIRE(header);
-            REQUIRE(*(header) == "header_value");
-        }
+    SECTION("Headers should be addable and retrievable from the request") {
+        test_request.add_header("header_name", "header_value");
+        auto header = test_request.header("header_name");
+        REQUIRE(header);
+        REQUIRE(*(header) == "header_value");
+    }
 
-        SECTION("Headers should be removable from the request") {
-            test_request.add_header("header_name", "header_value");
-            test_request.remove_header("header_name");
-            auto header = test_request.header("header_name");
-            REQUIRE(header == nullptr);
-        }
+    SECTION("Headers should be removable from the request") {
+        test_request.add_header("header_name", "header_value");
+        test_request.remove_header("header_name");
+        auto header = test_request.header("header_name");
+        REQUIRE(header == nullptr);
+    }
 
-        SECTION("Headers should be enumerable") {
-            int i = 0;
-            string expected_name, expected_value;
-            test_request.add_header("header_0", "header_value_0");
-            test_request.add_header("header_1", "header_value_1");
-            test_request.add_header("header_2", "header_value_2");
+    SECTION("Headers should be enumerable") {
+        int i = 0;
+        string expected_name, expected_value;
+        test_request.add_header("header_0", "header_value_0");
+        test_request.add_header("header_1", "header_value_1");
+        test_request.add_header("header_2", "header_value_2");
 
-            test_request.each_header([&](string const& name, string const& value) {
-                expected_name  = "header_" + to_string(i);
-                expected_value = "header_value_" + to_string(i);
-                REQUIRE(name == expected_name);
-                REQUIRE(value == expected_value);
-                ++i;
-                return true;
-            });
-        }
+        test_request.each_header([&](string const& name, string const& value) {
+            expected_name  = "header_" + to_string(i);
+            expected_value = "header_value_" + to_string(i);
+            REQUIRE(name == expected_name);
+            REQUIRE(value == expected_value);
+            ++i;
+            return true;
+        });
+    }
 
-        SECTION("A cookie should be retrievable by name") {
-            test_request.add_cookie("cookie_0", "cookie_val_0");
-            test_request.add_cookie("cookie_1", "cookie_val_1");
-            REQUIRE(*(test_request.cookie("cookie_0")) == "cookie_val_0");
-        }
+    SECTION("A cookie should be retrievable by name") {
+        test_request.add_cookie("cookie_0", "cookie_val_0");
+        test_request.add_cookie("cookie_1", "cookie_val_1");
+        REQUIRE(*(test_request.cookie("cookie_0")) == "cookie_val_0");
+    }
 
-        SECTION("Cookies should be enumerable") {
-            int i = 0;
-            string expected_name, expected_value;
-            test_request.add_cookie("cookie_0", "cookie_value_0");
-            test_request.add_cookie("cookie_1", "cookie_value_1");
-            test_request.add_cookie("cookie_2", "cookie_value_2");
+    SECTION("Cookies should be enumerable") {
+        int i = 0;
+        string expected_name, expected_value;
+        test_request.add_cookie("cookie_0", "cookie_value_0");
+        test_request.add_cookie("cookie_1", "cookie_value_1");
+        test_request.add_cookie("cookie_2", "cookie_value_2");
 
-            test_request.each_cookie([&](string const& name, string const& value) {
-                expected_name  = "cookie_" + to_string(i);
-                expected_value = "cookie_value_" + to_string(i);
-                REQUIRE(name == expected_name);
-                REQUIRE(value == expected_value);
-                ++i;
-                return true;
-            });
-        }
+        test_request.each_cookie([&](string const& name, string const& value) {
+            expected_name  = "cookie_" + to_string(i);
+            expected_value = "cookie_value_" + to_string(i);
+            REQUIRE(name == expected_name);
+            REQUIRE(value == expected_value);
+            ++i;
+            return true;
+        });
+    }
 
-        SECTION("Request body should be addable and retrievable") {
-            test_request.body("Hello, I am a request body!", "message");
-            auto body = test_request.body();
-            REQUIRE(body == "Hello, I am a request body!");
-        }
+    SECTION("Request body should be addable and retrievable") {
+        test_request.body("Hello, I am a request body!", "message");
+        auto body = test_request.body();
+        REQUIRE(body == "Hello, I am a request body!");
+    }
 
-        SECTION("Overall request timeout should be configurable and retrievable") {
-            test_request.timeout(100);
-            REQUIRE(test_request.timeout() == 100);
-        }
+    SECTION("Overall request timeout should be configurable and retrievable") {
+        test_request.timeout(100);
+        REQUIRE(test_request.timeout() == 100);
+    }
 
-        SECTION("Connection timeout should be configurable and retrievable") {
-            test_request.connection_timeout(100);
-            REQUIRE(test_request.connection_timeout() == 100);
-        }
+    SECTION("Connection timeout should be configurable and retrievable") {
+        test_request.connection_timeout(100);
+        REQUIRE(test_request.connection_timeout() == 100);
     }
-}}
+}

data/ext/facter/leatherman/curl/tests/response_test.cc

@@ -4,57 +4,55 @@
 #include <leatherman/curl/request.hpp>
 
 using namespace std;
+using namespace leatherman::curl;
 
-namespace leatherman { namespace curl {
-
-    struct mock_client : client {
-        curl_handle const& get_handle() { return client::get_handle(); }
-    };
-
-    TEST_CASE("curl::response") {
-        response test_response;
-
-        SECTION("Headers should be addable and retrievable from the response") {
-            test_response.add_header("header_name", "header_value");
-            auto header = test_response.header("header_name");
-            REQUIRE(header);
-            REQUIRE(*(header) == "header_value");
-        }
-
-        SECTION("Headers should be removable from the response") {
-            test_response.add_header("header_name", "header_value");
-            test_response.remove_header("header_name");
-            auto header = test_response.header("header_name");
-            REQUIRE(header == nullptr);
-        }
-
-        SECTION("Headers should be enumerable") {
-            int i = 0;
-            string expected_name, expected_value;
-            test_response.add_header("header_0", "header_value_0");
-            test_response.add_header("header_1", "header_value_1");
-            test_response.add_header("header_2", "header_value_2");
-
-            test_response.each_header([&](string const& name, string const& value) {
-                expected_name  = "header_" + to_string(i);
-                expected_value = "header_value_" + to_string(i);
-                REQUIRE(name == expected_name);
-                REQUIRE(value == expected_value);
-                ++i;
-                return true;
-            });
-        }
-
-        SECTION("Response body should be addable and retrievable") {
-            test_response.body("Hello, I am a response body!");
-            auto body = test_response.body();
-            REQUIRE(body == "Hello, I am a response body!");
-        }
-
-        SECTION("Status code should be addable and retrievable") {
-            test_response.status_code(200);
-            auto code = test_response.status_code();
-            REQUIRE(code == 200);
-        }
+struct mock_client : client {
+    curl_handle const& get_handle() { return client::get_handle(); }
+};
+
+TEST_CASE("curl::response") {
+    response test_response;
+
+    SECTION("Headers should be addable and retrievable from the response") {
+        test_response.add_header("header_name", "header_value");
+        auto header = test_response.header("header_name");
+        REQUIRE(header);
+        REQUIRE(*(header) == "header_value");
+    }
+
+    SECTION("Headers should be removable from the response") {
+        test_response.add_header("header_name", "header_value");
+        test_response.remove_header("header_name");
+        auto header = test_response.header("header_name");
+        REQUIRE(header == nullptr);
+    }
+
+    SECTION("Headers should be enumerable") {
+        int i = 0;
+        string expected_name, expected_value;
+        test_response.add_header("header_0", "header_value_0");
+        test_response.add_header("header_1", "header_value_1");
+        test_response.add_header("header_2", "header_value_2");
+
+        test_response.each_header([&](string const& name, string const& value) {
+            expected_name  = "header_" + to_string(i);
+            expected_value = "header_value_" + to_string(i);
+            REQUIRE(name == expected_name);
+            REQUIRE(value == expected_value);
+            ++i;
+            return true;
+        });
+    }
+
+    SECTION("Response body should be addable and retrievable") {
+        test_response.body("Hello, I am a response body!");
+        auto body = test_response.body();
+        REQUIRE(body == "Hello, I am a response body!");
+    }
+
+    SECTION("Status code should be addable and retrievable") {
+        test_response.status_code(200);
+        auto code = test_response.status_code();
+        REQUIRE(code == 200);
     }
-}}
+}

data/ext/facter/leatherman/dynamic_library/tests/dynamic_library_tests.cc

@@ -2,97 +2,93 @@
 #include <leatherman/dynamic_library/dynamic_library.hpp>
 #include "fixtures.hpp"
 
-namespace leatherman { namespace dynamic_library {
+using namespace leatherman::dynamic_library;
 
+std::string const lib_path = TEST_LIB_DIRECTORY + std::string("/libtest.so");
+std::string const lib_path2 = TEST_LIB_DIRECTORY + std::string("/libtest1.so");
 
-    std::string const lib_path = TEST_LIB_DIRECTORY + std::string("/libtest.so");
-    std::string const lib_path2 = TEST_LIB_DIRECTORY + std::string("/libtest1.so");
-
-
-    TEST_CASE("dynamic_library::load and dynamic_library::close", "[dyn-lib]") {
-        SECTION("should not be loaded by default") {
-            dynamic_library lib;
-            REQUIRE_FALSE(lib.loaded());
-        }
-
-        SECTION("should load library from path, then close it"){
-            dynamic_library lib;
-            REQUIRE(lib.load(lib_path));
-            REQUIRE(lib.loaded());
-            REQUIRE(lib.first_load());
-            lib.close();
-            REQUIRE_FALSE(lib.loaded());
-        }
-
-        SECTION("should fail to load a nonexistent library") {
-            dynamic_library lib;
-            REQUIRE_FALSE(lib.load("no_such_library"));
-        }
+TEST_CASE("dynamic_library::load and dynamic_library::close", "[dyn-lib]") {
+    SECTION("should not be loaded by default") {
+        dynamic_library lib;
+        REQUIRE_FALSE(lib.loaded());
     }
 
-    TEST_CASE("dynamic_library::find_symbol", "[dyn-lib]"){
+    SECTION("should load library from path, then close it"){
         dynamic_library lib;
         REQUIRE(lib.load(lib_path));
+        REQUIRE(lib.loaded());
+        REQUIRE(lib.first_load());
+        lib.close();
+        REQUIRE_FALSE(lib.loaded());
+    }
 
-        SECTION("should fail to find nonexistent symbol") {
-            REQUIRE_FALSE(lib.find_symbol("not_here"));
-            REQUIRE_THROWS(lib.find_symbol("not_here", true));
-        }
+    SECTION("should fail to load a nonexistent library") {
+        dynamic_library lib;
+        REQUIRE_FALSE(lib.load("no_such_library"));
+    }
+}
 
-        SECTION("should find library function") {
-            REQUIRE(lib.find_symbol("hello"));
-        }
+TEST_CASE("dynamic_library::find_symbol", "[dyn-lib]"){
+    dynamic_library lib;
+    REQUIRE(lib.load(lib_path));
 
-        SECTION("should find aliased symbol"){
-            dynamic_library lib2;
-            REQUIRE(lib2.load(lib_path2));
-            REQUIRE(lib2.find_symbol("not_here", false, "goodbye"));
-        }
+    SECTION("should fail to find nonexistent symbol") {
+        REQUIRE_FALSE(lib.find_symbol("not_here"));
+        REQUIRE_THROWS(lib.find_symbol("not_here", true));
     }
 
-    TEST_CASE("dynamic_library::dyanmic_library(dynamic_library && other)", "[dyn-lib]") {
-            SECTION("should move library to new variable") {
-                dynamic_library lib;
-                REQUIRE(lib.load(lib_path));
-                REQUIRE(lib.loaded());
-                dynamic_library lib2 = std::move(lib);
-                REQUIRE(lib2.loaded());
-                REQUIRE(lib2.name() == lib_path);
-                REQUIRE_FALSE(lib.loaded());
-            }
-        }
+    SECTION("should find library function") {
+        REQUIRE(lib.find_symbol("hello"));
+    }
+
+    SECTION("should find aliased symbol"){
+        dynamic_library lib2;
+        REQUIRE(lib2.load(lib_path2));
+        REQUIRE(lib2.find_symbol("not_here", false, "goodbye"));
+    }
+}
+
+TEST_CASE("dynamic_library::dyanmic_library(dynamic_library && other)", "[dyn-lib]") {
+    SECTION("should move library to new variable") {
+        dynamic_library lib;
+        REQUIRE(lib.load(lib_path));
+        REQUIRE(lib.loaded());
+        dynamic_library lib2 = std::move(lib);
+        REQUIRE(lib2.loaded());
+        REQUIRE(lib2.name() == lib_path);
+        REQUIRE_FALSE(lib.loaded());
+    }
+}
 
 #ifdef _WIN32
-    TEST_CASE("dynamic_library::find_by_pattern", "[dyn-lib]"){
-        SECTION("should fail to find a missing library"){
-            REQUIRE_FALSE(dynamic_library::find_by_pattern("libtest1").loaded());
-        }
+TEST_CASE("dynamic_library::find_by_pattern", "[dyn-lib]"){
+    SECTION("should fail to find a missing library"){
+        REQUIRE_FALSE(dynamic_library::find_by_pattern("libtest1").loaded());
+    }
 
-        SECTION("should find a library matching a pattern"){
-            dynamic_library lib;
-            lib.load(lib_path);
-            REQUIRE_FALSE(dynamic_library::find_by_pattern("libtest1").loaded());
-            dynamic_library lib2;
-            lib2.load(lib_path2);
-            REQUIRE(dynamic_library::find_by_pattern("libtest1").loaded());
-        }
+    SECTION("should find a library matching a pattern"){
+        dynamic_library lib;
+        lib.load(lib_path);
+        REQUIRE_FALSE(dynamic_library::find_by_pattern("libtest1").loaded());
+        dynamic_library lib2;
+        lib2.load(lib_path2);
+        REQUIRE(dynamic_library::find_by_pattern("libtest1").loaded());
     }
+}
 #else
-    TEST_CASE("dynamic_library::find_by_symbol", "[dyn-lib]"){
-        SECTION("should fail to find a missing symbol"){
-            REQUIRE_FALSE(dynamic_library::find_by_symbol("no_such_symbol").loaded());
-        }
+TEST_CASE("dynamic_library::find_by_symbol", "[dyn-lib]"){
+    SECTION("should fail to find a missing symbol"){
+        REQUIRE_FALSE(dynamic_library::find_by_symbol("no_such_symbol").loaded());
+    }
 
-        SECTION("should find a library with the given symbol"){
-            dynamic_library lib;
-            REQUIRE(lib.load(lib_path));
-            REQUIRE_FALSE(dynamic_library::find_by_symbol("goodbye").loaded());
-            dynamic_library lib2;
-            REQUIRE(lib2.load(lib_path2, true));
-            REQUIRE(lib2.find_symbol("goodbye"));
-            REQUIRE(dynamic_library::find_by_symbol("goodbye").loaded());
-        }
+    SECTION("should find a library with the given symbol"){
+        dynamic_library lib;
+        REQUIRE(lib.load(lib_path));
+        REQUIRE_FALSE(dynamic_library::find_by_symbol("goodbye").loaded());
+        dynamic_library lib2;
+        REQUIRE(lib2.load(lib_path2, true));
+        REQUIRE(lib2.find_symbol("goodbye"));
+        REQUIRE(dynamic_library::find_by_symbol("goodbye").loaded());
     }
+}
 #endif
-
-}}  // namespace leatherman::dynamic_library

data/ext/facter/leatherman/execution/src/execution.cc

@@ -233,6 +233,7 @@ namespace leatherman { namespace execution {
         vector<string> const& arguments,
         string const& input,
         map<string, string> const& environment,
+        // cppcheck-suppress passedByValue
         std::function<void(size_t)> pid_callback,
         uint32_t timeout,
         option_set<execution_options> const& options)
@@ -258,12 +259,14 @@ namespace leatherman { namespace execution {
     }
 
     result execute(
+        // cppcheck-suppress funcArgOrderDifferent
         std::string const& file,
         std::vector<std::string> const& arguments,
         std::string const& input,
         std::string const& out_file,
         std::string const& err_file,
         std::map<std::string, std::string> const& environment,
+        // cppcheck-suppress passedByValue
         std::function<void(size_t)> pid_callback,
         uint32_t timeout,
         boost::optional<fs::perms> perms,