void test_assignments () { std::cout << "///////////////////////////////////////////////////////////////////////////\n"; std::cout << "// Assignments //\n"; std::cout << "///////////////////////////////////////////////////////////////////////////\n"; typedef pfs::vector<int> int_vector; ADD_TESTS(4); // // Default copy assignment operator // int_vector v; int_vector v0; v = v0; TEST_OK(v.size() == v0.size()); TEST_OK(v.size() == 0); v.push_back(1); v.push_back(2); v.push_back(3); // // Copy assignment operator // int_vector v1; v1 = v; TEST_OK(v.size() == 3); TEST_OK(v1.size() == 3); #if __cplusplus >= 201103L ADD_TESTS(2); // // Move assignment operator // int_vector v2; v2 = std::move(v); TEST_OK(v.size() == 0); TEST_OK(v2.size() == 3); #endif }
void test_assignments () { std::cout << "///////////////////////////////////////////////////////////////////////////\n"; std::cout << "// Assignments //\n"; std::cout << "///////////////////////////////////////////////////////////////////////////\n"; typedef pfs::set<int> int_set; ADD_TESTS(4); // // Default copy assignment operator // int_set v; int_set v0; v = v0; TEST_OK(v.size() == v0.size()); TEST_OK(v.size() == 0); v.insert(1); v.insert(2); v.insert(3); // // Copy assignment operator // int_set v1; v1 = v; TEST_OK(v.size() == 3); TEST_OK(v1.size() == 3); #if __cplusplus >= 201103L ADD_TESTS(2); // // Move assignment operator // int_set v2; v2 = std::move(v); TEST_OK(v.size() == 0); TEST_OK(v2.size() == 3); #endif }
void test_sign_of () { std::cout << "///////////////////////////////////////////////////////////////////////////\n"; std::cout << "// sign_of //\n"; std::cout << "///////////////////////////////////////////////////////////////////////////\n"; ADD_TESTS(0); test_sign_of_signed_integral<char>(); test_sign_of_signed_integral<short>(); test_sign_of_signed_integral<int>(); test_sign_of_signed_integral<long int>(); #if PFS_HAVE_LONG_LONG test_sign_of_signed_integral<long long int>(); #endif test_sign_of_unsigned_integral<unsigned char>(); test_sign_of_unsigned_integral<unsigned short>(); test_sign_of_unsigned_integral<unsigned int>(); test_sign_of_unsigned_integral<unsigned long int>(); #if PFS_HAVE_LONG_LONG test_sign_of_unsigned_integral<unsigned long long int>(); #endif test_sign_of_fp<float>(); test_sign_of_fp<double>(); #if PFS_HAVE_LONG_DOUBLE test_sign_of_fp<long double>(); #endif }
void test_weak_ptr () { std::cout << "///////////////////////////////////////////////////////////////////////////\n"; std::cout << "// weak_ptr //\n"; std::cout << "///////////////////////////////////////////////////////////////////////////\n"; ADD_TESTS(6); pfs::weak_ptr<int> wp0; TEST_OK2(wp0.use_count() == 0, "Create weak_ptr with default constructor"); TEST_OK2(wp0.use_count() == 0, "weak_ptr().use_count() == 0"); TEST_OK2(wp0.expired() == true, "weak_ptr().expired() == true"); TEST_OK2(wp0.lock() == 0, "weak_ptr().lock() is nullptr"); pfs::weak_ptr<int> wp1; { pfs::shared_ptr<int> sp1 = pfs::make_shared<int>(42); wp1 = sp1; TEST_OK2(wp1.use_count() == 1, "Assign weak_ptr from shared_ptr"); } TEST_OK2(wp1.expired(), "weak_ptr automatically expired out of the scope"); // TODO Continue tests ... }
void canonical () { ADD_TESTS(1 + sizeof(canonical_data)/sizeof(canonical_data[0]) - 1); TEST_OK(path_type().canonical() == path_type()); canonical_data_t * p = & canonical_data[0]; while (!p->path_str.empty()) { std::ostringstream oss; path_type canonical = path_type(p->path_str).canonical(); oss << "'" << canonical.str() << "' is canonical for '" << p->path_str << "'"; bool result = canonical == path_type(p->canonical); if (!result) { oss << "' but expected '" << p->canonical << "'"; } TEST_OK2(result, oss.str().c_str()); ++p; } }
void test_json_iterator () { { ADD_TESTS(11); pfs::json::json json; json["Image"]["Width"] = 800; json["Image"]["Height"] = 600; json["Image"]["Title"] = _u8("View from 15th Floor"); json["Image"]["Thumbnail"]["Url"] = _u8("http://www.example.com/image/481989943"); json["Image"]["Thumbnail"]["Height"] = 125; json["Image"]["Thumbnail"]["Width"] = _u8("100"); json["Image"]["IDs"].push_back(116); json["Image"]["IDs"].push_back(943); json["Image"]["IDs"].push_back(234); json["Image"]["IDs"].push_back(38793); TEST_OK(json.size() == 1); TEST_OK(json.find("Image") != json.end()); TEST_OK(json["Image"].find("Title") != json["Image"].end()); TEST_OK(json["Image"].find("--unknown--") == json["Image"].end()); TEST_OK(json["Image"]["Thumbnail"].contains("Width")); TEST_OK(not json["Image"]["Thumbnail"].contains("--unknown--")); pfs::json::json::const_iterator it = json.cbegin(); TEST_OK(it->is_object()); TEST_OK(it->size() == 5); TEST_OK(++it == json.cend()); TEST_OK((--it)->is_object()); pfs::json::json::const_iterator it_image = it->cbegin(); TEST_OK(it_image->size() == 1); } { ADD_TESTS(2); pfs::json::json json; json["id"] = 1; pfs::json::json::const_iterator it = json.find("id"); TEST_OK(it != json.cend()); TEST_OK(it != json.end()); } }
void test_timezone () { ADD_TESTS(2); typedef pfs::timezone timezone_t; TEST_OK(pfs::timezone::offset_to_string(0L) == string_t("+0000")); TEST_OK(pfs::timezone::offset_to_string(18000L) == string_t("+0500")); }
void test_sign_of_signed_integral () { ADD_TESTS(7); TEST_OK(pfs::sign_of<T>(0) == 0); TEST_OK(pfs::sign_of<T>(-0) == 0); TEST_OK(pfs::sign_of<T>(+0) == 0); TEST_OK(pfs::sign_of<T>(1) == 1); TEST_OK(pfs::sign_of<T>(-1) == -1); TEST_OK(pfs::sign_of<T>(pfs::numeric_limits<T>::min()) == -1); TEST_OK(pfs::sign_of<T>(pfs::numeric_limits<T>::max()) == 1); }
void test_sign_of_fp () { ADD_TESTS(9); TEST_OK(pfs::sign_of<T>(0) == 0); TEST_OK(pfs::sign_of<T>(-0) == 0); TEST_OK(pfs::sign_of<T>(+0) == 0); TEST_OK(pfs::sign_of<T>(1) == 1); TEST_OK(pfs::sign_of<T>(-1) == -1); TEST_OK(pfs::sign_of<T>(pfs::numeric_limits<T>::min()) == 1); TEST_OK(pfs::sign_of<T>(pfs::numeric_limits<T>::max()) == 1); TEST_OK(pfs::sign_of<T>(-pfs::numeric_limits<T>::min()) == -1); TEST_OK(pfs::sign_of<T>(-pfs::numeric_limits<T>::max()) == -1); }
void test_trim () { typedef pfs::string<StringImplType> string_type; typedef typename string_type::const_pointer const_pointer; test_description<const_pointer>(__PRETTY_FUNCTION__); ADD_TESTS(21); TEST_OK(pfs::ltrim(string_type()) == string_type()); TEST_OK(pfs::ltrim(string_type()) == string_type("")); TEST_OK(pfs::rtrim(string_type()) == string_type()); TEST_OK(pfs::rtrim(string_type()) == string_type("")); TEST_OK(pfs::trim(string_type()) == string_type()); TEST_OK(pfs::trim(string_type()) == string_type("")); TEST_OK(pfs::ltrim(string_type("")) == string_type()); TEST_OK(pfs::ltrim(string_type("")) == string_type("")); TEST_OK(pfs::rtrim(string_type("")) == string_type()); TEST_OK(pfs::rtrim(string_type("")) == string_type("")); TEST_OK(pfs::trim(string_type("")) == string_type()); TEST_OK(pfs::trim(string_type("")) == string_type("")); TEST_OK(pfs::ltrim(string_type("Abc")) == string_type("Abc")); TEST_OK(pfs::ltrim(string_type(" Abc")) == string_type("Abc")); TEST_OK(pfs::ltrim(string_type(" Abc ")) == string_type("Abc ")); TEST_OK(pfs::rtrim(string_type("Abc")) == string_type("Abc")); TEST_OK(pfs::rtrim(string_type("Abc ")) == string_type("Abc")); TEST_OK(pfs::rtrim(string_type(" Abc ")) == string_type(" Abc")); TEST_OK(pfs::trim(string_type("Abc")) == string_type("Abc")); TEST_OK(pfs::trim(string_type("Abc ")) == string_type("Abc")); TEST_OK(pfs::trim(string_type(" Abc ")) == string_type("Abc")); }
void test () { ADD_TESTS(12); typedef pfs::json::reference_wrapper<json_type> ref_type; typedef pfs::json::reference_wrapper<json_type const> const_ref_type; json_type json; // null value //typename json_type::iterator it = json.begin(); json["Image"]["Width"] = 800; json["Image"]["Height"] = 600; json["Image"]["Title"] = "View from 15th Floor"; json["Image"]["Thumbnail"]["Url"] = "http://www.example.com/image/481989943"; json["Image"]["Thumbnail"]["Height"] = 125; json["Image"]["Thumbnail"]["Width"] = "100"; json["Image"]["IDs"].push_back(116); json["Image"]["IDs"].push_back(943); json["Image"]["IDs"].push_back(234); json["Image"]["IDs"].push_back(38793); ref_type jref(json); TEST_FAIL(jref["Image"]); TEST_FAIL(jref["Image"]["Width"]); TEST_OK(jref["Image"]["Width"].template get<int>() == 800); TEST_OK(jref["Image"]["Width1"].template get<int>(-1) == -1); TEST_OK(jref["Image"]["IDs"][3].template get<uint32_t>() == 38793); TEST_OK(jref["Image"]["IDs"][4].template get<uint32_t>(1111) == 1111); const_ref_type jconstref(json); TEST_FAIL(jconstref["Image"]); TEST_FAIL(jconstref["Image"]["Width"]); TEST_OK(jconstref["Image"]["Width"].template get<int>() == 800); TEST_OK(jconstref["Image"]["Width1"].template get<int>(-1) == -1); TEST_OK(jconstref["Image"]["IDs"][3].template get<uint32_t>() == 38793); TEST_OK(jconstref["Image"]["IDs"][4].template get<uint32_t>(1111) == 1111); }
int main(int argc, char **argv) { CU_pSuite suite; int ret, failed_num; pid_t pid; signal(SIGPIPE, SIG_IGN); // preprocessing of tests test_init(); pid = start_newtd(); if(pid > 0) { CU_initialize_registry(); ADD_TESTS(test_optparse); ADD_TESTS(test_config); ADD_TESTS(test_signal); ADD_TESTS(test_daemon); ADD_TESTS(test_frame); ADD_TESTS(test_stomp); ADD_TESTS(test_queue); ADD_TESTS(test_transaction); ADD_TESTS(test_persistent); ADD_TESTS(test_proto_connect); ADD_TESTS(test_proto_disconnect); ADD_TESTS(test_proto_subscribe); ADD_TESTS(test_proto_reply_to); ADD_TESTS(test_proto_topic); ADD_TESTS(test_proto_begin); ADD_TESTS(test_proto_error); ADD_TESTS(test_newtctl_worker); CU_basic_run_tests(); failed_num = CU_get_number_of_tests_failed(); CU_cleanup_registry(); kill(pid, SIGINT); wait(NULL); } return failed_num; }
void test_assignments () { std::cout << "///////////////////////////////////////////////////////////////////////////\n"; std::cout << "// Assignments //\n"; std::cout << "///////////////////////////////////////////////////////////////////////////\n"; ADD_TESTS(28); // // Default copy assignment operator // byte_string bs_default; bs_default = bs_sample; TEST_OK(bs_default.size() == std::strlen(raw_chars)); TEST_OK(std::strcmp(bs_default.c_str(), raw_chars) == 0); #if __cplusplus >= 201103L ADD_TESTS(3); // // Move Assignment // byte_string bs_move1(raw_bytes); byte_string bs_move2; bs_move2 = std::move(bs_move1); TEST_OK(bs_move1.size() == 0); TEST_OK(std::strcmp(bs_move1.c_str(), "") == 0); TEST_OK(std::strcmp(bs_move2.c_str(), raw_chars) == 0); #endif // // Assignment from raw const pointer // byte_string bs_from_raw; bs_from_raw = raw_bytes; TEST_OK(std::strcmp(bs_from_raw.c_str(), raw_chars) == 0); byte_string bs_from_raw1; bs_from_raw1 = raw_chars; TEST_OK(std::strcmp(bs_from_raw1.c_str(), raw_chars) == 0); // // Assignment from single value // byte_string bs_from_byte; bs_from_byte = raw_bytes[0]; TEST_OK(bs_from_byte.size() == 1); TEST_OK(std::strcmp(bs_from_byte.c_str(), "b") == 0); // // Assignment from single char // byte_string bs_from_char; bs_from_char = 'b'; TEST_OK(bs_from_char.size() == 1); TEST_OK(std::strcmp(bs_from_char.c_str(), "b") == 0); // // Assign from count copy of value // byte_string bs_rpt; bs_rpt.assign(4, raw_bytes[0]); TEST_OK(bs_rpt.size() == 4); TEST_OK(std::strcmp(bs_rpt.c_str(), "bbbb") == 0); // // Assign from count copy of value // byte_string bs_rpt1; bs_rpt1.assign(4, 'b'); TEST_OK(bs_rpt1.size() == 4); TEST_OK(std::strcmp(bs_rpt1.c_str(), "bbbb") == 0); // // Assigns from substring // byte_string bs_rpt2; bs_rpt2.assign(bs_sample, 0, bs_sample.size()); TEST_OK(bs_rpt2.size() == bs_sample.size()); TEST_OK(std::strcmp(bs_rpt2.c_str(), raw_chars) == 0); byte_string bs_rpt3; bs_rpt3.assign(bs_sample, 5, byte_string::npos); TEST_OK(bs_rpt3.size() == 6); TEST_OK(std::strcmp(bs_rpt3.c_str(), "string") == 0); byte_string bs_rpt4; bs_rpt4.assign(bs_sample, 2, 5); TEST_OK(bs_rpt4.size() == 5); TEST_OK(std::strcmp(bs_rpt4.c_str(), "te_st") == 0); // // Assigns from first count values // byte_string bs_count; bs_count.assign(raw_bytes, 4); TEST_OK(bs_count.size() == 4); TEST_OK(std::strcmp(bs_count.c_str(), "byte") == 0); byte_string bs_count1; bs_count1.assign(raw_chars, 4); TEST_OK(bs_count1.size() == 4); TEST_OK(std::strcmp(bs_count1.c_str(), "byte") == 0); // // Assigns from C string // byte_string bs_cstr; bs_cstr.assign(raw_bytes); TEST_OK(std::strcmp(bs_cstr.c_str(), raw_chars) == 0); byte_string bs_cstr1; bs_cstr1.assign(raw_chars); TEST_OK(std::strcmp(bs_cstr1.c_str(), raw_chars) == 0); // // Assigns from range // byte_string bs_range; bs_range.assign(raw_bytes, raw_bytes + std::strlen(raw_chars)); TEST_OK(std::strcmp(bs_range.c_str(), raw_chars) == 0); byte_string bs_range1; bs_range1.assign(raw_chars, raw_chars + std::strlen(raw_chars)); TEST_OK(std::strcmp(bs_range1.c_str(), raw_chars) == 0); byte_string bs_range2; bs_range2.assign(bs_from_raw.begin(), bs_from_raw.end()); TEST_OK(bs_range2.size() == bs_from_raw.size()); TEST_OK(std::strcmp(bs_range2.c_str(), raw_chars) == 0); }
void test_path () { typedef pfs::filesystem::path path; //////////////////////////////////////////////////////////////////////////////// // Constructors // //////////////////////////////////////////////////////////////////////////////// { ADD_TESTS(3); path p_from_cstr("/usr/lib/sendmail.cf"); path p_from_pfs_string(pfs::string("/usr/lib/sendmail.cf")); path p1 = "/usr/lib/sendmail.cf"; // portable format path p2 = "C:\\users\\abcdef\\AppData\\Local\\Temp\\"; // native format path p3 = L"D:/猫.txt"; // wide string // std::cout << "p1 = " << p1 << '\n' // << "p2 = " << p2 << '\n' // << "p3 = " << p3 << '\n'; TEST_OK(p1 == path::string_type("/usr/lib/sendmail.cf")); TEST_OK(p2 == path::string_type("C:\\users\\abcdef\\AppData\\Local\\Temp\\")); TEST_OK(p3 == path::string_type("D:/猫.txt")); } // Assign operators { ADD_TESTS(2); path p = "C:/users/abcdef/AppData/Local"; p = p / "Temp"; // move assignment TEST_OK(p == path::string_type("C:/users/abcdef/AppData/Local/Temp")); wchar_t const * wstr = L"D:/猫.txt"; p = wstr; // assignment from a source TEST_OK(p == path::string_type("D:/猫.txt")); } // // Concatenation #1 // { ADD_TESTS(4); // where "//host" is a root-name TEST_OK((path("//host") /= "foo") == path::string_type("//host/foo")); // appends with separator TEST_OK((path("//host/") /= "foo") == path::string_type("//host/foo")); // appends without separator // Non-member function TEST_OK(path("//host") / "foo" == path::string_type("//host/foo")); // appends with separator TEST_OK(path("//host/") / "foo" == path::string_type("//host/foo")); // appends without separator #if PFS_OS_POSIX ADD_TESTS(4); TEST_OK((path("foo") /= "") == path::string_type("foo")); // the result is "foo/" (appends) TEST_OK((path("foo") /= "/bar") == path::string_type("foo/bar")); // the result is "/bar" (replaces) // Non-member function TEST_OK(path("foo") / "" == path::string_type("foo")); // the result is "foo/" (appends) TEST_OK(path("foo") / "/bar" == path::string_type("foo/bar")); // the result is "/bar" (replaces) #endif #if PFS_OS_DOS ADD_TESTS(10); TEST_OK((path("foo") /= "C:/bar") == path::string_type("C:/bar")); // the result is "C:/bar" (replaces) TEST_OK((path("foo") /= "C:") == path::string_type("C:")); // the result is "C:" (replaces) TEST_OK((path("C:") /= "") == path::string_type("C:")); // the result is "C:" (appends, without separator) TEST_OK((path("C:foo") /= "/bar") == path::string_type("C:/bar")); // yields "C:/bar" (removes relative path, then appends) TEST_OK((path("C:foo") /= "C:bar") == path::string_type("C:foo/bar")); // yields "C:foo/bar" (appends, omitting p's root-name) // Non-member function TEST_OK(path("foo") / "C:/bar" == path::string_type("C:/bar")); // the result is "C:/bar" (replaces) TEST_OK(path("foo") / "C:" == path::string_type("C:")); // the result is "C:" (replaces) TEST_OK(path("C:") / "" == path::string_type("C:")); // the result is "C:" (appends, without separator) TEST_OK(path("C:foo") / "/bar" == path::string_type("C:/bar")); // yields "C:/bar" (removes relative path, then appends) TEST_OK(path("C:foo") / "C:bar" == path::string_type("C:foo/bar")); // yields "C:foo/bar" (appends, omitting p's root-name) #endif } // // Concatenation #2 // { ADD_TESTS(2); path p1; // empty path p1 += "var"; // does not insert a separator TEST_OK(p1 == path::string_type("var")); p1 += "lib"; // does not insert a separator TEST_OK(p1 == path::string_type("varlib")); } // // Modifiers #1 // { ADD_TESTS(2); path p("/path/to/file"); TEST_OK(!p.empty()); p.clear(); TEST_OK(p.empty()); } // // Modifiers #2 // { // TODO Test path::make_preferred() } // // Modifiers #3 // { ADD_TESTS(4); TEST_OK(path("foo/bar").remove_filename() == path::string_type("foo/")); // FAIL on C++11 TEST_OK(path("foo/").remove_filename() == path::string_type("foo/")); // FAIL on C++11 TEST_OK(path("/foo").remove_filename() == path::string_type("/")); TEST_OK(path("/").remove_filename() == path::string_type("/")); // FAIL on C++11 } // // Modifiers #4 // { ADD_TESTS(2); TEST_OK(path("/foo").replace_filename("bar") == path::string_type("/bar")); TEST_OK(path("/").replace_filename("bar") == path::string_type("bar")); } // // Modifiers #5 // { ADD_TESTS(2); path p = "/foo/bar.jpeg"; TEST_OK(p == path::string_type("/foo/bar.jpeg")); p.replace_extension(".jpg"); TEST_OK(p == path::string_type("/foo/bar.jpg")); } // // Modifiers #6 // { ADD_TESTS(4); path p1 = "/foo/bar"; path p2 = "/foo/baz"; TEST_OK(p1 == path::string_type("/foo/bar")); TEST_OK(p2 == path::string_type("/foo/baz")); p1.swap(p2); TEST_OK(p1 == path::string_type("/foo/baz")); TEST_OK(p2 == path::string_type("/foo/bar")); } // // Compare // { ADD_TESTS(3); path p1 = "/a/b/"; // as if "a/b/." for lexicographical iteration path p2 = "/a/b/#"; path p3 = "/a/b/_"; TEST_OK(p1.compare(p1) == 0); TEST_OK(p1.compare(p2) > 0); TEST_OK(p1.compare(p3) < 0); } // // Generation // { // TODO Implement path::lexically_xxx() methods // ADD_TESTS(8); // // TEST_OK(path("foo/./bar/..").lexically_normal() == "foo/"); // TEST_OK(path("foo/.///bar/../").lexically_normal() == "foo/"); // TEST_OK(path("/a/d").lexically_relative("/a/b/c") == "../../d"); // TEST_OK(path("/a/b/c").lexically_relative("/a/d") == "../b/c"); // TEST_OK(path("a/b/c").lexically_relative("a") == "b/c"); // TEST_OK(path("a/b/c").lexically_relative("a/b/c/x/y") == "../.."); // TEST_OK(path("a/b/c").lexically_relative("a/b/c") == "."); // TEST_OK(path("a/b").lexically_relative("c/d") == "../../a/b"); } // // Decomposition // { ADD_TESTS(29); TEST_OK(path("//server/path/to/file").root_name() == path("//server")); TEST_OK(path("//server/path/to/file").root_directory() == path("/")); TEST_OK(path("//server/path/to/file").root_path() == path("//server/")); TEST_OK(path("//server/path/to/file").relative_path() == path("path/to/file")); TEST_OK(path("//server/path/to/file").parent_path() == path("//server/path/to")); TEST_OK(path("/path/to/.").parent_path() == path("/path/to")); TEST_OK(path("/").parent_path() == path("")); TEST_OK(path("/foo/bar.txt").filename() == path("bar.txt")); TEST_OK(path("/foo/.bar").filename() == path(".bar")); TEST_OK(path("/foo/bar/").filename() == path(".")); TEST_OK(path("/foo/.").filename() == path(".")); TEST_OK(path("/foo/..").filename() == path("..")); TEST_OK(path(".").filename() == path(".")); TEST_OK(path("..").filename() == path("..")); TEST_OK(path("/").filename() == path("/")); TEST_OK(path("/foo/bar.txt").stem() == path::string_type("bar")); TEST_OK(path(".hidden").stem() == path::string_type(".hidden")) TEST_OK(path("/foo/.hidden").stem() == path::string_type(".hidden")); // FIXME (for std::experimental::filesystem::path::stem() returns "") TEST_OK(path("/foo/bar.txt").extension() == path::string_type(".txt")); TEST_OK(path("/foo/bar.").extension() == path::string_type(".")); TEST_OK(path("/foo/bar").extension() == path::string_type("")); TEST_OK(path("/foo/bar.txt/bar.cc").extension() == path::string_type(".cc")); TEST_OK(path("/foo/bar.txt/bar.").extension() == path::string_type(".")); TEST_OK(path("/foo/bar.txt/bar").extension() == path::string_type("")); TEST_OK(path("/foo/.").extension() == path::string_type("")); TEST_OK(path("/foo/..").extension() == path::string_type("")); TEST_OK(path(".hidden").extension() == path::string_type("")); TEST_OK(path("/foo/.hidden").extension() == path::string_type("")); // FIXME (for std::experimental::filesystem::path::extension() returns ".hidden") TEST_OK(path("/foo/..bar").extension() == path::string_type(".bar")); #if PFS_OS_DOS ADD_TESTS(7); TEST_OK(path("c:\\path\\to\\file").root_name() == path("c:")); TEST_OK(path("c:\\path\\to\\file").root_directory() == path("\\")); TEST_OK(path("c:\\path\\to\\file").root_path() == path("c:\\")); TEST_OK(path("c:\\path\\to\\file").relative_path() == path("path\\to\\file")); TEST_OK(path("c:\\path\\to\\file").parent_path() == path("c:\\path\\to")); TEST_OK(path("c:\\path\\to\\.").parent_path() == path("c:\\path\\to")); TEST_OK(path("\\").parent_path() == path("")); #endif } // // Queries // { ADD_TESTS(33); TEST_OK(!path("//server/path/to/file").empty()); TEST_OK(path("").empty()); TEST_OK(path().empty()); TEST_OK(path("//server/path/to/file").has_root_path()); TEST_OK(path("//server/path/to/file").has_root_name()); TEST_OK(path("//server/path/to/file").has_root_directory()); TEST_OK(path("//server/path/to/file").has_relative_path()); TEST_OK(path("//server/path/to/file").has_parent_path()); TEST_OK(path("/path/to/.").has_parent_path()); TEST_OK(!path("/").has_parent_path()); TEST_OK(path("/foo/bar.txt").has_filename()); TEST_OK(path("/foo/.bar").has_filename()); TEST_OK(path("/foo/bar/").has_filename()); TEST_OK(path("/foo/.").has_filename()); TEST_OK(path("/foo/..").has_filename()); TEST_OK(path(".").has_filename()); TEST_OK(path("..").has_filename()); TEST_OK(path("/").has_filename()); TEST_OK(path("/foo/bar.txt").has_stem()); TEST_OK(path(".hidden").has_stem()); TEST_OK(path("/foo/.hidden").has_stem()); // FIXME (for std::experimental::filesystem::path::stem() returns "") TEST_OK(path("/foo/bar.txt").has_extension()); TEST_OK(path("/foo/bar.").has_extension()); TEST_OK(!path("/foo/bar").has_extension()); TEST_OK(path("/foo/bar.txt/bar.cc").has_extension()); TEST_OK(path("/foo/bar.txt/bar.").has_extension()); TEST_OK(!path("/foo/bar.txt/bar").has_extension()); TEST_OK(!path("/foo/.").has_extension()); TEST_OK(!path("/foo/..").has_extension()); TEST_OK(!path(".hidden").has_extension()); TEST_OK(!path("/foo/.hidden").has_extension()); // FIXME (for std::experimental::filesystem::path::stem() returns ".hidden") TEST_OK(path("/foo/..bar").has_extension()); TEST_OK(path("path/to").is_relative()); #if PFS_OS_POSIX ADD_TESTS(1); // The path "/" is absolute on a POSIX OS, but is relative on Windows. TEST_OK(path("/").is_absolute()); #endif #if PFS_OS_DOS ADD_TESTS(1); // The path "/" is absolute on a POSIX OS, but is relative on Windows. TEST_OK(path("/").is_relative()); #endif } // // Iterators // { #if PFS_OS_POSIX ADD_TESTS(9); path p = "/home/user/abcdef/app_data/Local/Temp/"; path::iterator it = p.begin(); TEST_OK(*it++ == "/"); TEST_OK(*it++ == "home"); TEST_OK(*it++ == "user"); TEST_OK(*it++ == "abcdef"); TEST_OK(*it++ == "app_data"); TEST_OK(*it++ == "Local"); TEST_OK(*it++ == "Temp"); TEST_OK(*it++ == "."); TEST_OK(it == p.end()); //std::cout << *it << '\n'; #endif #if PFS_OS_DOS ADD_TESTS(9); path p = "C:\\users\\abcdef\\AppData\\Local\\Temp\\"; path::iterator it = p.begin(); TEST_OK(*it++ == "C:"); TEST_OK(*it++ == "/"); TEST_OK(*it++ == "users"); TEST_OK(*it++ == "abcdef"); TEST_OK(*it++ == "AppData"); TEST_OK(*it++ == "Local"); TEST_OK(*it++ == "Temp"); TEST_OK(*it++ == "."); TEST_OK(it == p.end()); #endif } // // Non-member functions // { ADD_TESTS(4); path p1("/path/to1"); path p2("/path/to2"); TEST_OK(p1 == path("/path/to1")); TEST_OK(p2 == path("/path/to2")); pfs::swap(p1, p2); TEST_OK(p1 == path("/path/to2")); TEST_OK(p2 == path("/path/to1")); } { ADD_TESTS(7); path p1("/path/to"); path p2("/path/to"); path p3("/path/to/a"); TEST_OK(p1 == p2); TEST_OK(p1 <= p2); TEST_OK(p1 >= p2); TEST_OK(p1 < p3); TEST_OK(p1 <= p3); TEST_OK(p3 > p1); TEST_OK(p3 >= p1); } }
void test_binary_ostream (OutputDevice & dev, byte_string & buffer) { typedef pfs::binary_ostream<OutputDevice> binary_ostream; ADD_TESTS(21); pfs::endian order = pfs::endian::network_order(); binary_ostream bos(dev, order); int i = 0; bos << bool(true); bos << bool(false); TEST_OK(buffer[i++] == 1); TEST_OK(buffer[i++] == 0); bos << 'A' << static_cast<int8_t>(0xDE) << static_cast<uint8_t>(0xAD); TEST_OK(buffer[i++] == 'A'); TEST_OK(buffer[i++] == 0xDE); TEST_OK(buffer[i++] == 0xAD); bos << static_cast<int16_t>(0xDEAD) << static_cast<uint16_t>(0xBEEF); TEST_OK(buffer[i++] == 0xDE); TEST_OK(buffer[i++] == 0xAD); TEST_OK(buffer[i++] == 0xBE); TEST_OK(buffer[i++] == 0xEF); bos << static_cast<int32_t>(0xDEADBEEF) << static_cast<uint32_t>(0xABADBABE); TEST_OK(buffer[i++] == 0xDE); TEST_OK(buffer[i++] == 0xAD); TEST_OK(buffer[i++] == 0xBE); TEST_OK(buffer[i++] == 0xEF); TEST_OK(buffer[i++] == 0xAB); TEST_OK(buffer[i++] == 0xAD); TEST_OK(buffer[i++] == 0xBA); TEST_OK(buffer[i++] == 0xBE); #if PFS_HAVE_INT64 ADD_TESTS(16) bos << static_cast<int64_t>(0xDEADBEEFABADBABE) << static_cast<uint64_t>(0xABADBABEDEADBEEF); TEST_OK(buffer[i++] == 0xDE); TEST_OK(buffer[i++] == 0xAD); TEST_OK(buffer[i++] == 0xBE); TEST_OK(buffer[i++] == 0xEF); TEST_OK(buffer[i++] == 0xAB); TEST_OK(buffer[i++] == 0xAD); TEST_OK(buffer[i++] == 0xBA); TEST_OK(buffer[i++] == 0xBE); TEST_OK(buffer[i++] == 0xAB); TEST_OK(buffer[i++] == 0xAD); TEST_OK(buffer[i++] == 0xBA); TEST_OK(buffer[i++] == 0xBE); TEST_OK(buffer[i++] == 0xDE); TEST_OK(buffer[i++] == 0xAD); TEST_OK(buffer[i++] == 0xBE); TEST_OK(buffer[i++] == 0xEF); #endif bos << static_cast<real32_t>(0x4E9D3A75); TEST_OK(buffer[i++] == 0x4E); TEST_OK(buffer[i++] == 0x9D); TEST_OK(buffer[i++] == 0x3A); TEST_OK(buffer[i++] == 0x75); #if PFS_HAVE_INT64 ADD_TESTS(8); bos << static_cast<real64_t>(0x43D0F43D0F43D0F4); TEST_OK(buffer[i++] == 0x43); TEST_OK(buffer[i++] == 0xD0); TEST_OK(buffer[i++] == 0xF4); TEST_OK(buffer[i++] == 0x3D); TEST_OK(buffer[i++] == 0x0F); TEST_OK(buffer[i++] == 0x43); TEST_OK(buffer[i++] == 0xD0); TEST_OK(buffer[i++] == 0xF4); #endif }