cfacter 3.11.0.rc.20180314

data/ext/facter/leatherman/vendor/nowide/test/test_fs.cpp

@@ -0,0 +1,48 @@
+//
+//  Copyright (c) 2015 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#include <boost/nowide/integration/filesystem.hpp>
+#include <boost/nowide/fstream.hpp>
+#include <boost/nowide/cstdio.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/filesystem.hpp>
+#include <iostream>
+
+#include "test.hpp"
+
+static char const *utf8_name = "\xf0\x9d\x92\x9e-\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82-\xE3\x82\x84\xE3\x81\x82.txt";
+static wchar_t const *wide_name = L"\U0001D49E-\u043F\u0440\u0438\u0432\u0435\u0442-\u3084\u3042.txt";
+
+int main()
+{   
+    try {
+
+    boost::nowide::nowide_filesystem();        
+        
+        TEST(boost::nowide::widen(utf8_name) == wide_name);
+        TEST(boost::nowide::narrow(wide_name) == utf8_name);
+        
+        boost::nowide::ofstream f(utf8_name);
+        TEST(f);
+        f << "Test" << std::endl;
+        f.close();
+        TEST(boost::filesystem::is_regular_file(wide_name)==true);
+        TEST(boost::filesystem::is_regular_file(utf8_name)==true);
+        boost::nowide::remove(utf8_name);
+        TEST(boost::filesystem::is_regular_file(utf8_name)==false);
+        TEST(boost::filesystem::is_regular_file(wide_name)==false);
+        
+    }
+    catch(std::exception const &e) {
+        std::cerr << "Failed : " << e.what() << std::endl;
+        return 1;
+    }
+    std::cout << "Ok" << std::endl;
+    return 0;
+}
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

data/ext/facter/leatherman/vendor/nowide/test/test_fstream.cpp

@@ -0,0 +1,184 @@
+#include <boost/nowide/fstream.hpp>
+#include <boost/nowide/cstdio.hpp>
+#include <iostream>
+
+#include <iostream>
+#include "test.hpp"
+
+#ifdef BOOST_MSVC
+#  pragma warning(disable : 4996)
+#endif
+
+
+int main()
+{
+    
+    char const *example = "\xd7\xa9-\xd0\xbc-\xce\xbd" ".txt";
+#ifdef BOOST_WINDOWS
+    wchar_t const *wexample = L"\u05e9-\u043c-\u03bd.txt";
+#endif    
+
+    try {
+        namespace nw=boost::nowide;
+        
+        std::cout << "Testing fstream" << std::endl;
+        {
+            nw::ofstream fo;
+            fo.open(example);
+            TEST(fo);
+            fo<<"test"<<std::endl;
+            fo.close();
+            #ifdef BOOST_WINDOWS
+            {
+                FILE *tmp=_wfopen(wexample,L"r");
+                TEST(tmp);
+                TEST(fgetc(tmp)=='t');
+                TEST(fgetc(tmp)=='e');
+                TEST(fgetc(tmp)=='s');
+                TEST(fgetc(tmp)=='t');
+                TEST(fgetc(tmp)=='\n');
+                TEST(fgetc(tmp)==EOF);
+                fclose(tmp);
+            }
+            #endif
+            {
+                nw::ifstream fi;
+                fi.open(example);
+                TEST(fi);
+                std::string tmp;
+                fi  >> tmp;
+                TEST(tmp=="test");
+                fi.close();
+            }
+            {
+                nw::ifstream fi(example);
+                TEST(fi);
+                std::string tmp;
+                fi  >> tmp;
+                TEST(tmp=="test");
+                fi.close();
+            }
+            #if defined(BOOST_WINDOWS) || defined(BOOST_NOWIDE_FSTREAM_TESTS) 
+            // C++11 interfaces aren't enabled at all platforms so need to skip
+            // for std::*fstream
+            {
+                std::string name = example;
+                nw::ifstream fi(name);
+                TEST(fi);
+                std::string tmp;
+                fi  >> tmp;
+                TEST(tmp=="test");
+                fi.close();
+            }
+            {
+                nw::ifstream fi;
+                fi.open(std::string(example));
+                TEST(fi);
+                std::string tmp;
+                fi  >> tmp;
+                TEST(tmp=="test");
+                fi.close();
+            }
+            #endif
+            {
+                nw::ifstream fi(example,std::ios::binary);
+                TEST(fi);
+                std::string tmp;
+                fi  >> tmp;
+                TEST(tmp=="test");
+                fi.close();
+            }
+
+            {
+                nw::ifstream fi;
+                nw::remove(example);
+                fi.open(example);
+                TEST(!fi);
+            }
+            {
+                nw::fstream f(example,nw::fstream::in | nw::fstream::out | nw::fstream::trunc | nw::fstream::binary);
+                TEST(f);
+                f << "test2" ;
+                std::string tmp;
+                f.seekg(0);
+                f>> tmp;
+                TEST(tmp=="test2");
+                f.close();
+            }
+            {
+                nw::ifstream fi(example,nw::fstream::ate | nw::fstream::binary);
+                TEST(fi);
+                TEST(fi.tellg()==std::streampos(5));
+                fi.seekg(-2,std::ios_base::cur);
+                std::string tmp;
+                fi >> tmp;
+                TEST(tmp == "t2");
+                fi.close();
+            }
+            nw::remove(example);
+        }
+        
+        for(int i=-1;i<16;i++) {
+            std::cout << "Complex io with buffer = " << i << std::endl;
+            char buf[16];
+            nw::fstream f;
+            if(i==0)
+                f.rdbuf()->pubsetbuf(0,0);
+            else if (i > 0) 
+                f.rdbuf()->pubsetbuf(buf,i);
+            
+            f.open(example,nw::fstream::in | nw::fstream::out | nw::fstream::trunc | nw::fstream::binary);
+            f.put('a');
+            f.put('b');
+            f.put('c');
+            f.put('d');
+            f.put('e');
+            f.put('f');
+            f.put('g');
+            f.seekg(0);
+            TEST(f.get()=='a');
+            f.seekg(1,std::ios::cur);
+            TEST(f.get()=='c');
+            f.seekg(-1,std::ios::cur);
+            TEST(f.get()=='c');
+            TEST(f.seekg(1));
+            f.put('B');
+            TEST(f.get()=='c');
+            TEST(f.seekg(1));
+            TEST(f.get() == 'B');
+            f.seekg(2);
+            f.put('C');
+            TEST(f.get()=='d');
+            f.seekg(0);
+            TEST(f.get()=='a');
+            TEST(f.get()=='B');
+            TEST(f.get()=='C');
+            TEST(f.get()=='d');
+            TEST(f.get()=='e');
+            TEST(f.putback('e'));
+            TEST(f.putback('d'));
+            TEST(f.get()=='d');
+            TEST(f.get()=='e');
+            TEST(f.get()=='f');
+            TEST(f.get()=='g');
+            TEST(f.get()==EOF);
+            f.clear();
+            f.seekg(1);
+            TEST(f.get()=='B');
+            TEST(f.putback('B'));
+            TEST(f.putback('a'));
+            TEST(!f.putback('x'));
+            f.close();
+            TEST(boost::nowide::remove(example)==0);
+            
+        }
+            
+    }
+    catch(std::exception const &e) {
+        std::cerr << e.what() << std::endl;
+        return 1;
+    }
+    std::cout << "Ok" << std::endl;
+    return 0;
+
+}

data/ext/facter/leatherman/vendor/nowide/test/test_iostream.cpp

@@ -0,0 +1,52 @@
+#include <boost/nowide/iostream.hpp>
+
+#include "test.hpp"
+
+
+int main(int argc,char **argv)
+{
+    
+    char const *example = "Basic letters: \xd7\xa9-\xd0\xbc-\xce\xbd\n"
+                          "East Asian Letters: \xe5\x92\x8c\xe5\xb9\xb3\n"
+                          "Non-BMP letters: \xf0\x9d\x84\x9e\n";
+
+    try {
+        int maxval = 15000;
+        for(int i=0;i<maxval;i++) {
+            char c = i % 96 + ' ';
+            TEST(boost::nowide::cin.putback(c));
+        }
+        for(int i=maxval-1;i>=0;i--) {
+            int c = i % 96 + ' ';
+            TEST(boost::nowide::cin.get() == c);
+        }
+        std::string v1,v2;
+        boost::nowide::cout << "Normal I/O:" << std::endl;
+        boost::nowide::cout << example << std::endl;
+        boost::nowide::cerr << example << std::endl;
+        
+        boost::nowide::cout << "Flushing each character:" << std::endl;
+        
+        for(char const *s=example;*s;s++) {
+            boost::nowide::cout << *s << std::flush;
+            TEST(boost::nowide::cout);
+        }
+        
+        TEST(boost::nowide::cout);
+        TEST(boost::nowide::cerr);
+        if(argc==2 && argv[1]==std::string("-i")) {
+            boost::nowide::cin  >> v1 >> v2;
+            TEST(boost::nowide::cin);
+            boost::nowide::cout << "First:  "<< v1 << std::endl;
+            boost::nowide::cout << "Second: "<< v2 << std::endl;
+            TEST(boost::nowide::cout);
+        }
+    }
+    catch(std::exception const &e) {
+        std::cerr << "Fail: " << e.what() << std::endl;
+        return 1;
+    }
+    std::cout <<"Ok" << std::endl;
+    return 0;
+
+}

data/ext/facter/leatherman/vendor/nowide/test/test_stdio.cpp

@@ -0,0 +1,60 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/nowide/cstdio.hpp>
+#include <iostream>
+#include <string.h>
+#include "test.hpp"
+
+#ifdef BOOST_MSVC
+#  pragma warning(disable : 4996)
+#endif
+
+
+int main()
+{
+    try {
+        std::string example = "\xd7\xa9-\xd0\xbc-\xce\xbd.txt";
+        std::wstring wexample = L"\u05e9-\u043c-\u03bd.txt";
+
+        #ifdef BOOST_WINDOWS
+        FILE *f=_wfopen(wexample.c_str(),L"w");
+        #else
+        FILE *f=std::fopen(example.c_str(),"w");
+        #endif
+        TEST(f);
+        std::fprintf(f,"test\n");
+        std::fclose(f);
+        f=0;
+        
+        TEST((f=boost::nowide::fopen(example.c_str(),"r"))!=0);
+        char buf[16];
+        TEST(std::fgets(buf,16,f)!=0);
+        TEST(strcmp(buf,"test\n")==0);
+        TEST((f=boost::nowide::freopen(example.c_str(),"r+",f))!=0);
+        std::fclose(f);
+        f=0;
+        
+        TEST(boost::nowide::rename(example.c_str(),(example+".1").c_str())==0);
+        TEST(boost::nowide::remove(example.c_str())<0);
+        TEST((f=boost::nowide::fopen((example+".1").c_str(),"r"))!=0);
+        std::fclose(f);
+        f=0;
+        TEST(boost::nowide::remove(example.c_str())<0);
+        TEST(boost::nowide::remove((example+".1").c_str())==0);
+    }
+    catch(std::exception const &e) {
+        std::cerr << "Failed " << e.what() << std::endl;
+        return 1;
+    }
+    std::cout << "Ok" << std::endl;
+    return 0;
+}
+
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

data/ext/facter/leatherman/vendor/nowide/test/test_system.cpp

@@ -0,0 +1,91 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/nowide/system.hpp>
+#include <boost/nowide/args.hpp>
+#include <boost/nowide/cenv.hpp>
+#include <iostream>
+#include "test.hpp"
+#include <stdio.h>
+
+int main(int argc,char **argv,char **env)
+{
+    try {
+        std::string example = "\xd7\xa9-\xd0\xbc-\xce\xbd";
+        std::wstring wexample = L"\u05e9-\u043c-\u03bd";
+        boost::nowide::args a(argc,argv,env);
+        if(argc==2 && argv[1][0]!='-') {
+            TEST(argv[1]==example);
+            TEST(argv[2] == 0);
+            TEST(boost::nowide::getenv("BOOST_NOWIDE_TEST"));
+            TEST(boost::nowide::getenv("BOOST_NOWIDE_TEST_NONE") == 0);
+            TEST(boost::nowide::getenv("BOOST_NOWIDE_TEST")==example);
+            std::string sample = "BOOST_NOWIDE_TEST=" + example;
+            bool found = false;
+            for(char **e=env;*e!=0;e++) {
+				char *eptr = *e;
+				//printf("%s\n",eptr);
+                char *key_end = strchr(eptr,'=');
+                TEST(key_end);
+                std::string key = std::string(eptr,key_end);
+                std::string value = key_end + 1;
+		        TEST(boost::nowide::getenv(key.c_str()));
+                TEST(boost::nowide::getenv(key.c_str()) == value);
+                if(*e == sample)
+                    found = true;
+            }
+            TEST(found);
+            std::cout << "Subprocess ok" << std::endl;
+        }
+        else if(argc==2 && argv[1][0]=='-') {
+            switch(argv[1][1]) {
+            case 'w': 
+                {
+                    #ifdef BOOST_WINDOWS
+                    std::wstring env = L"BOOST_NOWIDE_TEST=" + wexample;
+                    _wputenv(env.c_str());
+                    std::wstring wcommand = boost::nowide::widen(argv[0]);
+                    wcommand += L" ";
+                    wcommand += wexample;
+                    TEST(_wsystem(wcommand.c_str()) == 0);
+                    std::cout << "Wide Parent ok" << std::endl;
+                    #else
+                    std::cout << "Wide API is irrelevant" << std::endl;
+                    #endif
+                }
+                return 0;
+            case 'n':
+                TEST(boost::nowide::setenv("BOOST_NOWIDE_TEST",example.c_str(),1) == 0);
+                TEST(boost::nowide::setenv("BOOST_NOWIDE_TEST_NONE",example.c_str(),1) == 0);
+                TEST(boost::nowide::unsetenv("BOOST_NOWIDE_TEST_NONE") == 0);
+                break;
+            default:
+                std::cout << "Invalid parameters expected '-n/-w'" << std::endl;
+                return 1;
+            }
+            std::string command = "\"";
+            command += argv[0];
+            command += "\" ";
+            command += example;
+            TEST(boost::nowide::system(command.c_str()) == 0);
+            std::cout << "Parent ok" << std::endl;
+        }
+        else {
+            std::cerr << "Invalid parameters" << std::endl;
+            return 1;
+        }
+        return 0;
+    }
+    catch(std::exception const &e) {
+        std::cerr << "Failed " << e.what() << std::endl;
+        return 1;
+    }
+}
+
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

data/ext/facter/leatherman/windows/CMakeLists.txt

@@ -0,0 +1,27 @@
+find_package(Boost 1.54 REQUIRED COMPONENTS filesystem)
+
+add_leatherman_deps(Wbemuuid.lib userenv.lib "${Boost_LIBRARIES}")
+add_leatherman_includes("${Boost_INCLUDE_DIRS}")
+
+leatherman_dependency(nowide)
+leatherman_dependency(locale)
+leatherman_dependency(logging)
+leatherman_dependency(util)
+
+if (BUILDING_LEATHERMAN)
+    leatherman_logging_namespace("leatherman.windows")
+    leatherman_logging_line_numbers()
+endif()
+
+set(WINDOWS_UTIL_SOURCES
+  "src/file_util.cc"
+  "src/registry.cc"
+  "src/process.cc"
+  "src/user.cc"
+  "src/wmi.cc"
+  "src/system_error.cc"
+)
+
+add_leatherman_library(${WINDOWS_UTIL_SOURCES})
+add_leatherman_headers(inc/leatherman)
+add_leatherman_test(tests/file_utils_test.cc)