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

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

@@ -161,6 +161,7 @@ namespace leatherman { namespace execution {
     // Represents information about a pipe
     struct pipe
     {
+        // cppcheck-suppress passedByValue
         pipe(string pipe_name, scoped_descriptor desc, function<bool(string const&)> cb) :
             name(move(pipe_name)),
             descriptor(move(desc)),
@@ -169,6 +170,7 @@ namespace leatherman { namespace execution {
         {
         }
 
+        // cppcheck-suppress passedByValue
         pipe(string pipe_name, scoped_descriptor desc, string buf) :
             name(move(pipe_name)),
             descriptor(move(desc)),
@@ -221,8 +223,7 @@ namespace leatherman { namespace execution {
             int result = select(max + 1, &read_set, &write_set, nullptr, timeout ? &read_timeout : nullptr);
             if (result == -1) {
                 if (errno != EINTR) {
-                    LOG_ERROR(format_error(_("select call failed")));
-                    throw execution_exception(_("child i/o failed."));
+                    throw execution_exception(format_error(_("select call failed waiting for child i/o")));
                 }
                 // Interrupted by signal
                 LOG_DEBUG("select call was interrupted and will be retried.");
@@ -505,15 +506,13 @@ namespace leatherman { namespace execution {
             struct sigaction sa = {};
             sa.sa_handler = timer_handler;
             if (sigaction(SIGALRM, &sa, nullptr) == -1) {
-                LOG_ERROR(format_error(_("sigaction failed")));
-                throw execution_exception(format_error(_("failed to setup timer")));
+                throw execution_exception(format_error(_("sigaction failed while setting up timeout")));
             }
 
             itimerval timer = {};
             timer.it_value.tv_sec = static_cast<decltype(timer.it_interval.tv_sec)>(timeout);
             if (setitimer(ITIMER_REAL, &timer, nullptr) == -1) {
-                LOG_ERROR(format_error(_("setitimer failed")));
-                throw execution_exception(format_error(_("failed to setup timer")));
+                throw execution_exception(format_error(_("setitimer failed while setting up timeout")));
             }
 
             // Set the resource to disable the timer

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

@@ -215,6 +215,7 @@ namespace leatherman { namespace execution {
     // Represents information about a pipe
     struct pipe
     {
+        // cppcheck-suppress passedByValue
         pipe(string pipe_name, scoped_handle pipe_handle, function<bool(string const&)> cb) :
             name(move(pipe_name)),
             handle(move(pipe_handle)),
@@ -226,6 +227,7 @@ namespace leatherman { namespace execution {
             init();
         }
 
+        // cppcheck-suppress passedByValue
         pipe(string pipe_name, scoped_handle pipe_handle, string buf) :
             name(move(pipe_name)),
             handle(move(pipe_handle)),

data/ext/facter/leatherman/execution/tests/windows/execution.cc

@@ -143,8 +143,10 @@ SCENARIO("executing commands with execution::execute") {
             auto exec = execute("cmd.exe", { "/c", CMAKE_BIN_DIRECTORY "/lth_cat.exe", "prefix", "suffix", "overwhelm", "stderr" },
                 "hello\ngoodbye", 0, { execution_options::merge_environment });
             REQUIRE(exec.success);
-            REQUIRE(exec.output == lth_cat::prefix+lth_cat::overwhelm+"hello\n"+lth_cat::overwhelm+"goodbye\n"+lth_cat::overwhelm+lth_cat::suffix);
-            REQUIRE(exec.error == "hello\ngoodbye\n");
+            auto expected = lth_cat::prefix+lth_cat::overwhelm+"hello\n"+lth_cat::overwhelm+"goodbye\n"+lth_cat::overwhelm+lth_cat::suffix;
+            boost::replace_all(expected, "\n", "\r\n");
+            REQUIRE(exec.output == expected);
+            REQUIRE(exec.error == "hello\r\ngoodbye\r\n");
             REQUIRE(exec.exit_code == 0);
         }
         WHEN("requested to write stdout to file") {

data/ext/facter/leatherman/file_util/tests/directory_utils_test.cc

@@ -4,86 +4,84 @@
 #include "fixtures.hpp"
 #include <boost/filesystem.hpp>
 
-namespace leatherman { namespace file_util {
+using namespace leatherman::file_util;
 
-    TEST_CASE("file_util::each_file", "[utils]") {
+TEST_CASE("file_util::each_file", "[utils]") {
 
-        temp_directory directory;
-        atomic_write_to_file("1\n", directory.get_dir_name() + "/test1");
-        atomic_write_to_file("2\n", directory.get_dir_name() + "/test2");
-        atomic_write_to_file("3\n", directory.get_dir_name() + "/test3");
+    temp_directory directory;
+    atomic_write_to_file("1\n", directory.get_dir_name() + "/test1");
+    atomic_write_to_file("2\n", directory.get_dir_name() + "/test2");
+    atomic_write_to_file("3\n", directory.get_dir_name() + "/test3");
 
-        SECTION("each file should be visited") {
-            std::set<std::string> file_contents;
-            each_file(directory.get_dir_name(), [&file_contents](std::string const &path) {
-                file_contents.insert(read(path));
-                return true;
-            });
-            REQUIRE(file_contents.size() == 3u);
-            REQUIRE(file_contents.find("1\n") != file_contents.end());
-            REQUIRE(file_contents.find("2\n") != file_contents.end());
-            REQUIRE(file_contents.find("3\n") != file_contents.end());
-        }
-
-        SECTION("can find a file to match a pattern") {
-            std::string content = "N/A";
-            each_file(directory.get_dir_name(), [&content](std::string const &path) {
-                return read(path, content);
-            }, "[0-1]");
-            REQUIRE(content == "1\n");
-        }
+    SECTION("each file should be visited") {
+        std::set<std::string> file_contents;
+        each_file(directory.get_dir_name(), [&file_contents](std::string const &path) {
+            file_contents.insert(read(path));
+            return true;
+        });
+        REQUIRE(file_contents.size() == 3u);
+        REQUIRE(file_contents.find("1\n") != file_contents.end());
+        REQUIRE(file_contents.find("2\n") != file_contents.end());
+        REQUIRE(file_contents.find("3\n") != file_contents.end());
+    }
 
-        SECTION("only one file returned from false callback"){
-            int count = 0;
-            each_file(directory.get_dir_name(), [&count](std::string const& path){
-                count++;
-                return false;
-            });
-            REQUIRE(count == 1);
-        }
+    SECTION("can find a file to match a pattern") {
+        std::string content = "N/A";
+        each_file(directory.get_dir_name(), [&content](std::string const &path) {
+            return read(path, content);
+        }, "[0-1]");
+        REQUIRE(content == "1\n");
+    }
 
+    SECTION("only one file returned from false callback"){
+        int count = 0;
+        each_file(directory.get_dir_name(), [&count](std::string const& path){
+            count++;
+            return false;
+        });
+        REQUIRE(count == 1);
     }
 
-    TEST_CASE("file_util::each_subdirectory", "[utils]") {
-        temp_directory directory;
-        boost::filesystem::create_directory(directory.get_dir_name() + "/test1");
-        atomic_write_to_file("1", directory.get_dir_name() + "/test1/t1");
-        boost::filesystem::create_directory(directory.get_dir_name() + "/test2");
-        atomic_write_to_file("2a", directory.get_dir_name() + "/test2/t2a");
-        atomic_write_to_file("2b", directory.get_dir_name() + "/test2/t2b");
+}
+
+TEST_CASE("file_util::each_subdirectory", "[utils]") {
+    temp_directory directory;
+    boost::filesystem::create_directory(directory.get_dir_name() + "/test1");
+    atomic_write_to_file("1", directory.get_dir_name() + "/test1/t1");
+    boost::filesystem::create_directory(directory.get_dir_name() + "/test2");
+    atomic_write_to_file("2a", directory.get_dir_name() + "/test2/t2a");
+    atomic_write_to_file("2b", directory.get_dir_name() + "/test2/t2b");
 
-        SECTION("each subdirectory should be visited") {
-            int counter = 0;
-            each_subdirectory(directory.get_dir_name(), [&counter](std::string const &path) {
-                each_file(path, [&counter](std::string const &file) {
-                    counter++;
-                    return true;
-                });
+    SECTION("each subdirectory should be visited") {
+        int counter = 0;
+        each_subdirectory(directory.get_dir_name(), [&counter](std::string const &path) {
+            each_file(path, [&counter](std::string const &file) {
+                counter++;
                 return true;
             });
-            REQUIRE(counter == 3);
-        }
+            return true;
+        });
+        REQUIRE(counter == 3);
+    }
 
-        SECTION("can find directories that match a pattern") {
-            int counter = 0;
-            each_subdirectory(directory.get_dir_name(), [&counter](std::string const &path) {
-                each_file(path, [&counter](std::string const &file) {
-                    counter++;
-                    return true;
-                });
+    SECTION("can find directories that match a pattern") {
+        int counter = 0;
+        each_subdirectory(directory.get_dir_name(), [&counter](std::string const &path) {
+            each_file(path, [&counter](std::string const &file) {
+                counter++;
                 return true;
-            }, "[2-3]");
-            REQUIRE(counter == 2);
-        }
-
-        SECTION("only one directory found from false callback"){
-            int count = 0;
-            each_subdirectory(directory.get_dir_name(), [&count](std::string const& path){
-                count++;
-                return false;
             });
-            REQUIRE(count == 1);
-        }
+            return true;
+        }, "[2-3]");
+        REQUIRE(counter == 2);
     }
 
-}}  //namespace leatherman::file_util
+    SECTION("only one directory found from false callback"){
+        int count = 0;
+        each_subdirectory(directory.get_dir_name(), [&count](std::string const& path){
+            count++;
+            return false;
+        });
+        REQUIRE(count == 1);
+    }
+}

data/ext/facter/leatherman/file_util/tests/file_utils_test.cc

@@ -7,191 +7,189 @@
 #include <windows.h>
 #endif
 
-namespace leatherman { namespace file_util {
+using namespace leatherman::file_util;
 
-    TEST_CASE("file_util::tilde_expand", "[utils]") {
+TEST_CASE("file_util::tilde_expand", "[utils]") {
 
 #ifdef _WIN32
-        _putenv("USERPROFILE=/testhome");
+    _putenv("USERPROFILE=/testhome");
 #else
-        setenv("HOME", "/testhome", 1);
+    setenv("HOME", "/testhome", 1);
 #endif
 
-        SECTION("empty path should be empty") {
-            REQUIRE(tilde_expand("") == "");
-        }
-
-        SECTION("spaces should be preserved") {
-            REQUIRE(tilde_expand("i like spaces") == "i like spaces");
-        }
-
-        SECTION("should expand using environment variable") {
-            CHECK(tilde_expand("~") == "/testhome");
-            CHECK(tilde_expand("~/") == "/testhome/");
-            CHECK(tilde_expand("~/foo") == "/testhome/foo");
-        }
-
-        SECTION("only a ~ at the start") {
-            REQUIRE(tilde_expand("/foo/bar~") == "/foo/bar~");
-        }
-
-        SECTION("~baz/foo does not expand") {
-            REQUIRE(tilde_expand("~baz/foo") == "~baz/foo");
-        }
-
-        SECTION("it should expand the home directory path") {
-            REQUIRE(tilde_expand("~/foo") != "~/foo");
-        }
-
-        SECTION("it should not expand the working directory path") {
-            REQUIRE(tilde_expand("./foo") == "./foo");
-        }
-
-        auto home_path = get_home_path();
-
-        SECTION("it should expand ~ to the HOME env var") {
-            REQUIRE(tilde_expand("~") == home_path);
-        }
-
-        SECTION("it should expand ~ as the base directory") {
-            std::string expected_path{home_path + "/spam"};
-            std::string expanded_path{tilde_expand("~/spam")};
-            REQUIRE(expanded_path == expected_path);
-        }
-    }
-
-    TEST_CASE("shell_quote", "[utils]") {
-        SECTION("empty string") {
-            REQUIRE(shell_quote("") == "\"\"");
-        }
-
-        SECTION("single word") {
-            REQUIRE(shell_quote("plain") == "\"plain\"");
-        }
-
-        SECTION("words separated by space") {
-            REQUIRE(shell_quote("a space") == "\"a space\"");
-        }
-
-        SECTION("exclamation mark") {
-            REQUIRE(shell_quote("!csh") == "\"!csh\"");
-        }
-
-        SECTION("single quote before expression") {
-            REQUIRE(shell_quote("'open quote") == "\"'open quote\"");
-        }
-
-        SECTION("single quote after expression") {
-            REQUIRE(shell_quote("close quote'") == "\"close quote'\"");
-        }
-
-        SECTION("double quote before expression") {
-            REQUIRE(shell_quote("\"open doublequote")
-                    == "\"\\\"open doublequote\"");
-        }
-
-        SECTION("double quote after expression") {
-            REQUIRE(shell_quote("close doublequote\"")
-                    == "\"close doublequote\\\"\"");
-        }
-    }
-
-    TEST_CASE("lth_file::file_readable", "[utils]") {
-        SECTION("it can check that a file does not exist") {
-            auto file_path = unique_fixture_path().string();
-            CAPTURE(file_path);
-            REQUIRE_FALSE(file_readable(file_path));
-        }
-
-        SECTION("directories are not readable") {
-            temp_directory dir_path;
-            REQUIRE_FALSE(file_readable(dir_path.get_dir_name()));
-        }
-    }
-
-    TEST_CASE("lth_file::atomic_write_to_file", "[utils]") {
-        SECTION("it can write to a regular file, ensure it exists, and delete it") {
-            auto file_path = unique_fixture_path().string();
-            REQUIRE_FALSE(file_readable(file_path));
-            atomic_write_to_file("test\n", file_path);
-            REQUIRE(file_readable(file_path));
-            boost::filesystem::remove(file_path);
-            REQUIRE_FALSE(file_readable(file_path));
-        }
-
-        SECTION("can write to an existing file") {
-            temp_file file("existing file");
-            REQUIRE(file_readable(file.get_file_name()));
-            atomic_write_to_file("test", file.get_file_name());
-            REQUIRE(file_readable(file.get_file_name()));
-            REQUIRE(read(file.get_file_name()) == "test");
-        }
+    SECTION("empty path should be empty") {
+        REQUIRE(tilde_expand("") == "");
+    }
+
+    SECTION("spaces should be preserved") {
+        REQUIRE(tilde_expand("i like spaces") == "i like spaces");
+    }
+
+    SECTION("should expand using environment variable") {
+        CHECK(tilde_expand("~") == "/testhome");
+        CHECK(tilde_expand("~/") == "/testhome/");
+        CHECK(tilde_expand("~/foo") == "/testhome/foo");
+    }
+
+    SECTION("only a ~ at the start") {
+        REQUIRE(tilde_expand("/foo/bar~") == "/foo/bar~");
+    }
+
+    SECTION("~baz/foo does not expand") {
+        REQUIRE(tilde_expand("~baz/foo") == "~baz/foo");
+    }
+
+    SECTION("it should expand the home directory path") {
+        REQUIRE(tilde_expand("~/foo") != "~/foo");
+    }
+
+    SECTION("it should not expand the working directory path") {
+        REQUIRE(tilde_expand("./foo") == "./foo");
+    }
+
+    auto home_path = get_home_path();
+
+    SECTION("it should expand ~ to the HOME env var") {
+        REQUIRE(tilde_expand("~") == home_path);
+    }
+
+    SECTION("it should expand ~ as the base directory") {
+        std::string expected_path{home_path + "/spam"};
+        std::string expanded_path{tilde_expand("~/spam")};
+        REQUIRE(expanded_path == expected_path);
+    }
+}
+
+TEST_CASE("shell_quote", "[utils]") {
+    SECTION("empty string") {
+        REQUIRE(shell_quote("") == "\"\"");
+    }
+
+    SECTION("single word") {
+        REQUIRE(shell_quote("plain") == "\"plain\"");
+    }
+
+    SECTION("words separated by space") {
+        REQUIRE(shell_quote("a space") == "\"a space\"");
+    }
+
+    SECTION("exclamation mark") {
+        REQUIRE(shell_quote("!csh") == "\"!csh\"");
+    }
+
+    SECTION("single quote before expression") {
+        REQUIRE(shell_quote("'open quote") == "\"'open quote\"");
+    }
+
+    SECTION("single quote after expression") {
+        REQUIRE(shell_quote("close quote'") == "\"close quote'\"");
+    }
+
+    SECTION("double quote before expression") {
+        REQUIRE(shell_quote("\"open doublequote")
+                == "\"\\\"open doublequote\"");
+    }
+
+    SECTION("double quote after expression") {
+        REQUIRE(shell_quote("close doublequote\"")
+                == "\"close doublequote\\\"\"");
+    }
+}
+
+TEST_CASE("lth_file::file_readable", "[utils]") {
+    SECTION("it can check that a file does not exist") {
+        auto file_path = unique_fixture_path().string();
+        CAPTURE(file_path);
+        REQUIRE_FALSE(file_readable(file_path));
+    }
+
+    SECTION("directories are not readable") {
+        temp_directory dir_path;
+        REQUIRE_FALSE(file_readable(dir_path.get_dir_name()));
+    }
+}
+
+TEST_CASE("lth_file::atomic_write_to_file", "[utils]") {
+    SECTION("it can write to a regular file, ensure it exists, and delete it") {
+        auto file_path = unique_fixture_path().string();
+        REQUIRE_FALSE(file_readable(file_path));
+        atomic_write_to_file("test\n", file_path);
+        REQUIRE(file_readable(file_path));
+        boost::filesystem::remove(file_path);
+        REQUIRE_FALSE(file_readable(file_path));
+    }
+
+    SECTION("can write to an existing file") {
+        temp_file file("existing file");
+        REQUIRE(file_readable(file.get_file_name()));
+        atomic_write_to_file("test", file.get_file_name());
+        REQUIRE(file_readable(file.get_file_name()));
+        REQUIRE(read(file.get_file_name()) == "test");
+    }
 
 #ifndef _WIN32
-        SECTION("can write a file with permissions") {
-            auto file_path = unique_fixture_path().string();
-            REQUIRE_FALSE(file_readable(file_path));
-            auto perms = boost::filesystem::owner_read | boost::filesystem::owner_write;
-            atomic_write_to_file("test\n", file_path, perms, std::ios::binary);
-            REQUIRE(file_readable(file_path));
-            auto stat = boost::filesystem::status(file_path);
-            REQUIRE(stat.permissions() == perms);
-            boost::filesystem::remove(file_path);
-            REQUIRE_FALSE(file_readable(file_path));
-        }
+    SECTION("can write a file with permissions") {
+        auto file_path = unique_fixture_path().string();
+        REQUIRE_FALSE(file_readable(file_path));
+        auto perms = boost::filesystem::owner_read | boost::filesystem::owner_write;
+        atomic_write_to_file("test\n", file_path, perms, std::ios::binary);
+        REQUIRE(file_readable(file_path));
+        auto stat = boost::filesystem::status(file_path);
+        REQUIRE(stat.permissions() == perms);
+        boost::filesystem::remove(file_path);
+        REQUIRE_FALSE(file_readable(file_path));
+    }
 #endif
+}
+
+TEST_CASE("file_util::read", "[utils]") {
+
+    SECTION("trying to read a nonexistent file returns the empty string"){
+        std::string contents;
+        REQUIRE(read("does_not_exist") == "");
+        REQUIRE_FALSE(read("does_not_exist", contents));
+        REQUIRE(contents.empty());
+    }
+
+    SECTION("it can read from a file") {
+        auto file_path = unique_fixture_path().string();
+        atomic_write_to_file("test\n", file_path);
+        REQUIRE(file_readable(file_path));
+        std::string contents;
+        REQUIRE(read(file_path, contents));
+        REQUIRE(contents == "test\n");
+        REQUIRE(read(file_path) == "test\n");
+        boost::filesystem::remove(file_path);
     }
+}
 
-    TEST_CASE("file_util::read", "[utils]") {
-
-        SECTION("trying to read a nonexistent file returns the empty string"){
-            std::string contents;
-            REQUIRE(read("does_not_exist") == "");
-            REQUIRE_FALSE(read("does_not_exist", contents));
-            REQUIRE(contents.empty());
-        }
-
-        SECTION("it can read from a file") {
-            auto file_path = unique_fixture_path().string();
-            atomic_write_to_file("test\n", file_path);
-            REQUIRE(file_readable(file_path));
-            std::string contents;
-            REQUIRE(read(file_path, contents));
-            REQUIRE(contents == "test\n");
-            REQUIRE(read(file_path) == "test\n");
-            boost::filesystem::remove(file_path);
-        }
-    }
-
-    TEST_CASE("file_util::each_line", "[utils]") {
-
-        SECTION("trying to read a nonexistent file returns false") {
-            REQUIRE_FALSE(each_line("does_not_exist", [](std::string &line) {
-                FAIL("should not be called");
-                return true;
-            }));
-        }
-
-        SECTION("an action is performed on each line of a file") {
-            temp_file file("test1\ntest2\ntest3\n");
-            int i = 0;
-            REQUIRE(each_line(file.get_file_name(), [&i](std::string const &line) {
-                i++;
-                return line == ("test" + std::to_string(i));
-            }));
-            REQUIRE(i == 3);
-        }
-
-        SECTION("a callback that returns false stops at the first line"){
-            temp_file file("test1\ntest2\ntest3\n");
-            std::vector<std::string> lines;
-            REQUIRE(each_line(file.get_file_name(), [&](std::string& line) {
-                lines.emplace_back(move(line));
-                return false;
-            }));
-            REQUIRE(lines.size() == 1u);
-            REQUIRE(lines[0] == "test1");
-        }
-    }
-
-}}  // namespace leatherman::file_util
+TEST_CASE("file_util::each_line", "[utils]") {
+
+    SECTION("trying to read a nonexistent file returns false") {
+        REQUIRE_FALSE(each_line("does_not_exist", [](std::string &line) {
+            FAIL("should not be called");
+            return true;
+        }));
+    }
+
+    SECTION("an action is performed on each line of a file") {
+        temp_file file("test1\ntest2\ntest3\n");
+        int i = 0;
+        REQUIRE(each_line(file.get_file_name(), [&i](std::string const &line) {
+            i++;
+            return line == ("test" + std::to_string(i));
+        }));
+        REQUIRE(i == 3);
+    }
+
+    SECTION("a callback that returns false stops at the first line"){
+        temp_file file("test1\ntest2\ntest3\n");
+        std::vector<std::string> lines;
+        REQUIRE(each_line(file.get_file_name(), [&](std::string& line) {
+            lines.emplace_back(move(line));
+            return false;
+        }));
+        REQUIRE(lines.size() == 1u);
+        REQUIRE(lines[0] == "test1");
+    }
+}