diff --git a/tdutils/test/port.cpp b/tdutils/test/port.cpp index 943776c1c..9238dd826 100644 --- a/tdutils/test/port.cpp +++ b/tdutils/test/port.cpp @@ -21,34 +21,38 @@ #include "td/utils/tests.h" #include "td/utils/Time.h" +#if TD_PORT_POSIX && !TD_THREAD_UNSUPPORTED +#include #include -#include +#include -using namespace td; +#include +#include +#endif TEST(Port, files) { - CSlice main_dir = "test_dir"; - rmrf(main_dir).ignore(); - ASSERT_TRUE(FileFd::open(main_dir, FileFd::Write).is_error()); - ASSERT_TRUE(walk_path(main_dir, [](CSlice name, WalkPath::Type type) { UNREACHABLE(); }).is_error()); - mkdir(main_dir).ensure(); - mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "A").ensure(); - mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "B").ensure(); - mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "B" << TD_DIR_SLASH << "D").ensure(); - mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "C").ensure(); - ASSERT_TRUE(FileFd::open(main_dir, FileFd::Write).is_error()); - std::string fd_path = PSTRING() << main_dir << TD_DIR_SLASH << "t.txt"; - std::string fd2_path = PSTRING() << main_dir << TD_DIR_SLASH << "C" << TD_DIR_SLASH << "t2.txt"; + td::CSlice main_dir = "test_dir"; + td::rmrf(main_dir).ignore(); + ASSERT_TRUE(td::FileFd::open(main_dir, td::FileFd::Write).is_error()); + ASSERT_TRUE(td::walk_path(main_dir, [](td::CSlice name, td::WalkPath::Type type) { UNREACHABLE(); }).is_error()); + td::mkdir(main_dir).ensure(); + td::mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "A").ensure(); + td::mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "B").ensure(); + td::mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "B" << TD_DIR_SLASH << "D").ensure(); + td::mkdir(PSLICE() << main_dir << TD_DIR_SLASH << "C").ensure(); + ASSERT_TRUE(td::FileFd::open(main_dir, td::FileFd::Write).is_error()); + td::string fd_path = PSTRING() << main_dir << TD_DIR_SLASH << "t.txt"; + td::string fd2_path = PSTRING() << main_dir << TD_DIR_SLASH << "C" << TD_DIR_SLASH << "t2.txt"; - auto fd = FileFd::open(fd_path, FileFd::Write | FileFd::CreateNew).move_as_ok(); - auto fd2 = FileFd::open(fd2_path, FileFd::Write | FileFd::CreateNew).move_as_ok(); + auto fd = td::FileFd::open(fd_path, td::FileFd::Write | td::FileFd::CreateNew).move_as_ok(); + auto fd2 = td::FileFd::open(fd2_path, td::FileFd::Write | td::FileFd::CreateNew).move_as_ok(); fd2.close(); int cnt = 0; const int ITER_COUNT = 1000; for (int i = 0; i < ITER_COUNT; i++) { - walk_path(main_dir, [&](CSlice name, WalkPath::Type type) { - if (type == WalkPath::Type::NotDir) { + td::walk_path(main_dir, [&](td::CSlice name, td::WalkPath::Type type) { + if (type == td::WalkPath::Type::NotDir) { ASSERT_TRUE(name == fd_path || name == fd2_path); } cnt++; @@ -56,28 +60,28 @@ TEST(Port, files) { } ASSERT_EQ((5 * 2 + 2) * ITER_COUNT, cnt); bool was_abort = false; - walk_path(main_dir, [&](CSlice name, WalkPath::Type type) { + td::walk_path(main_dir, [&](td::CSlice name, td::WalkPath::Type type) { CHECK(!was_abort); - if (type == WalkPath::Type::EnterDir && ends_with(name, PSLICE() << TD_DIR_SLASH << "B")) { + if (type == td::WalkPath::Type::EnterDir && ends_with(name, PSLICE() << TD_DIR_SLASH << "B")) { was_abort = true; - return WalkPath::Action::Abort; + return td::WalkPath::Action::Abort; } - return WalkPath::Action::Continue; + return td::WalkPath::Action::Continue; }).ensure(); CHECK(was_abort); cnt = 0; bool is_first_dir = true; - walk_path(main_dir, [&](CSlice name, WalkPath::Type type) { + td::walk_path(main_dir, [&](td::CSlice name, td::WalkPath::Type type) { cnt++; - if (type == WalkPath::Type::EnterDir) { + if (type == td::WalkPath::Type::EnterDir) { if (is_first_dir) { is_first_dir = false; } else { - return WalkPath::Action::SkipDir; + return td::WalkPath::Action::SkipDir; } } - return WalkPath::Action::Continue; + return td::WalkPath::Action::Continue; }).ensure(); ASSERT_EQ(6, cnt); @@ -85,13 +89,13 @@ TEST(Port, files) { ASSERT_EQ(12u, fd.write("Hello world!").move_as_ok()); ASSERT_EQ(4u, fd.pwrite("abcd", 1).move_as_ok()); char buf[100]; - MutableSlice buf_slice(buf, sizeof(buf)); + td::MutableSlice buf_slice(buf, sizeof(buf)); ASSERT_TRUE(fd.pread(buf_slice.substr(0, 4), 2).is_error()); fd.seek(11).ensure(); ASSERT_EQ(2u, fd.write("?!").move_as_ok()); - ASSERT_TRUE(FileFd::open(main_dir, FileFd::Read | FileFd::CreateNew).is_error()); - fd = FileFd::open(fd_path, FileFd::Read | FileFd::Create).move_as_ok(); + ASSERT_TRUE(td::FileFd::open(main_dir, td::FileFd::Read | td::FileFd::CreateNew).is_error()); + fd = td::FileFd::open(fd_path, td::FileFd::Read | td::FileFd::Create).move_as_ok(); ASSERT_EQ(13u, fd.get_size().move_as_ok()); ASSERT_EQ(4u, fd.pread(buf_slice.substr(0, 4), 1).move_as_ok()); ASSERT_STREQ("abcd", buf_slice.substr(0, 4)); @@ -102,53 +106,48 @@ TEST(Port, files) { } TEST(Port, SparseFiles) { - CSlice path = "sparse.txt"; - unlink(path).ignore(); - auto fd = FileFd::open(path, FileFd::Write | FileFd::CreateNew).move_as_ok(); + td::CSlice path = "sparse.txt"; + td::unlink(path).ignore(); + auto fd = td::FileFd::open(path, td::FileFd::Write | td::FileFd::CreateNew).move_as_ok(); ASSERT_EQ(0, fd.get_size().move_as_ok()); - int64 offset = 100000000; + td::int64 offset = 100000000; fd.pwrite("a", offset).ensure(); ASSERT_EQ(offset + 1, fd.get_size().move_as_ok()); auto real_size = fd.get_real_size().move_as_ok(); if (real_size >= offset + 1) { LOG(ERROR) << "File system doesn't support sparse files, rewind during streaming can be slow"; } - unlink(path).ensure(); + td::unlink(path).ensure(); } TEST(Port, Writev) { - std::vector vec; - CSlice test_file_path = "test.txt"; - unlink(test_file_path).ignore(); - auto fd = FileFd::open(test_file_path, FileFd::Write | FileFd::CreateNew).move_as_ok(); - vec.push_back(as_io_slice("a")); - vec.push_back(as_io_slice("b")); - vec.push_back(as_io_slice("cd")); + td::vector vec; + td::CSlice test_file_path = "test.txt"; + td::unlink(test_file_path).ignore(); + auto fd = td::FileFd::open(test_file_path, td::FileFd::Write | td::FileFd::CreateNew).move_as_ok(); + vec.push_back(td::as_io_slice("a")); + vec.push_back(td::as_io_slice("b")); + vec.push_back(td::as_io_slice("cd")); ASSERT_EQ(4u, fd.writev(vec).move_as_ok()); vec.clear(); - vec.push_back(as_io_slice("efg")); - vec.push_back(as_io_slice("")); - vec.push_back(as_io_slice("hi")); + vec.push_back(td::as_io_slice("efg")); + vec.push_back(td::as_io_slice("")); + vec.push_back(td::as_io_slice("hi")); ASSERT_EQ(5u, fd.writev(vec).move_as_ok()); fd.close(); - fd = FileFd::open(test_file_path, FileFd::Read).move_as_ok(); - Slice expected_content = "abcdefghi"; - ASSERT_EQ(static_cast(expected_content.size()), fd.get_size().ok()); - std::string content(expected_content.size(), '\0'); + fd = td::FileFd::open(test_file_path, td::FileFd::Read).move_as_ok(); + td::Slice expected_content = "abcdefghi"; + ASSERT_EQ(static_cast(expected_content.size()), fd.get_size().ok()); + td::string content(expected_content.size(), '\0'); ASSERT_EQ(content.size(), fd.read(content).move_as_ok()); ASSERT_EQ(expected_content, content); } #if TD_PORT_POSIX && !TD_THREAD_UNSUPPORTED -#include -#include - -#include -#include static std::mutex m; -static std::vector ptrs; -static std::vector addrs; +static td::vector ptrs; +static td::vector addrs; static TD_THREAD_LOCAL int thread_id; static void on_user_signal(int sig) { @@ -159,21 +158,21 @@ static void on_user_signal(int sig) { } TEST(Port, SignalsAndThread) { - setup_signals_alt_stack().ensure(); - set_signal_handler(SignalType::User, on_user_signal).ensure(); + td::setup_signals_alt_stack().ensure(); + td::set_signal_handler(td::SignalType::User, on_user_signal).ensure(); SCOPE_EXIT { - set_signal_handler(SignalType::User, nullptr).ensure(); + td::set_signal_handler(td::SignalType::User, nullptr).ensure(); }; - std::vector ans = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}; + td::vector ans = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}; { - std::vector threads; + td::vector threads; int thread_n = 10; - std::vector stages(thread_n); + td::vector stages(thread_n); ptrs.clear(); addrs.resize(thread_n); for (int i = 0; i < 10; i++) { threads.emplace_back([&, i] { - setup_signals_alt_stack().ensure(); + td::setup_signals_alt_stack().ensure(); if (i != 0) { stages[i].wait(2); } @@ -190,13 +189,12 @@ TEST(Port, SignalsAndThread) { CHECK(ptrs == ans); //LOG(ERROR) << ptrs; - //LOG(ERROR) << std::set(addrs.begin(), addrs.end()).size(); //LOG(ERROR) << addrs; } { - Stage stage; - std::vector threads; + td::Stage stage; + td::vector threads; int thread_n = 10; ptrs.clear(); addrs.resize(thread_n); @@ -219,16 +217,16 @@ TEST(Port, SignalsAndThread) { } TEST(Port, EventFdAndSignals) { - set_signal_handler(SignalType::User, [](int signal) {}).ensure(); + td::set_signal_handler(td::SignalType::User, [](int signal) {}).ensure(); SCOPE_EXIT { - set_signal_handler(SignalType::User, nullptr).ensure(); + td::set_signal_handler(td::SignalType::User, nullptr).ensure(); }; std::atomic_flag flag; flag.test_and_set(); auto main_thread = pthread_self(); td::thread interrupt_thread{[&flag, &main_thread] { - setup_signals_alt_stack().ensure(); + td::setup_signals_alt_stack().ensure(); while (flag.test_and_set()) { pthread_kill(main_thread, SIGUSR1); td::usleep_for(1000 * td::Random::fast(1, 10)); // 0.001s - 0.01s @@ -238,7 +236,7 @@ TEST(Port, EventFdAndSignals) { for (int timeout_ms : {0, 1, 2, 10, 100, 500}) { double min_diff = 10000000; double max_diff = 0; - for (int t = 0; t < max(5, 1000 / td::max(timeout_ms, 1)); t++) { + for (int t = 0; t < td::max(5, 1000 / td::max(timeout_ms, 1)); t++) { td::EventFd event_fd; event_fd.init(); auto start = td::Timestamp::now();