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
}
