diff options
Diffstat (limited to 'libs/tdlib/td/test/tdclient.cpp')
| -rw-r--r-- | libs/tdlib/td/test/tdclient.cpp | 837 |
1 files changed, 0 insertions, 837 deletions
diff --git a/libs/tdlib/td/test/tdclient.cpp b/libs/tdlib/td/test/tdclient.cpp deleted file mode 100644 index 7cef0fcbc0..0000000000 --- a/libs/tdlib/td/test/tdclient.cpp +++ /dev/null @@ -1,837 +0,0 @@ -// -// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018 -// -// 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 "data.h" - -#include "td/actor/PromiseFuture.h" - -#include "td/telegram/ClientActor.h" - -#include "td/telegram/td_api.h" - -#include "td/utils/base64.h" -#include "td/utils/BufferedFd.h" -#include "td/utils/filesystem.h" -#include "td/utils/format.h" -#include "td/utils/logging.h" -#include "td/utils/misc.h" -#include "td/utils/port/FileFd.h" -#include "td/utils/port/path.h" -#include "td/utils/Random.h" -#include "td/utils/Slice.h" -#include "td/utils/Status.h" -#include "td/utils/tests.h" - -#include <cstdio> -#include <functional> -#include <map> -#include <memory> -#include <utility> - -REGISTER_TESTS(tdclient); - -namespace td { - -template <class T> -static void check_td_error(T &result) { - CHECK(result->get_id() != td_api::error::ID) << to_string(result); -} - -static void rmrf(CSlice path) { - td::walk_path(path, [](CSlice path, bool is_dir) { - if (is_dir) { - td::rmdir(path).ignore(); - } else { - td::unlink(path).ignore(); - } - }); -} - -class TestClient : public Actor { - public: - explicit TestClient(string name) : name_(std::move(name)) { - } - struct Update { - uint64 id; - tl_object_ptr<td_api::Object> object; - Update(uint64 id, tl_object_ptr<td_api::Object> object) : id(id), object(std::move(object)) { - } - }; - class Listener { - public: - Listener() = default; - Listener(const Listener &) = delete; - Listener &operator=(const Listener &) = delete; - Listener(Listener &&) = delete; - Listener &operator=(Listener &&) = delete; - virtual ~Listener() = default; - virtual void start_listen(TestClient *client) { - } - virtual void stop_listen() { - } - virtual void on_update(std::shared_ptr<Update> update) = 0; - }; - void close(Promise<> close_promise) { - close_promise_ = std::move(close_promise); - td_.reset(); - } - - unique_ptr<TdCallback> make_td_callback() { - class TdCallbackImpl : public TdCallback { - public: - explicit TdCallbackImpl(ActorId<TestClient> client) : client_(client) { - } - void on_result(uint64 id, tl_object_ptr<td_api::Object> result) override { - send_closure(client_, &TestClient::on_result, id, std::move(result)); - } - void on_error(uint64 id, tl_object_ptr<td_api::error> error) override { - send_closure(client_, &TestClient::on_error, id, std::move(error)); - } - void on_closed() override { - send_closure(client_, &TestClient::on_closed); - } - - private: - ActorId<TestClient> client_; - }; - return make_unique<TdCallbackImpl>(actor_id(this)); - } - - void add_listener(std::unique_ptr<Listener> listener) { - auto *ptr = listener.get(); - listeners_.push_back(std::move(listener)); - ptr->start_listen(this); - } - void remove_listener(Listener *listener) { - pending_remove_.push_back(listener); - } - void do_pending_remove_listeners() { - for (auto listener : pending_remove_) { - do_remove_listener(listener); - } - pending_remove_.clear(); - } - void do_remove_listener(Listener *listener) { - for (size_t i = 0; i < listeners_.size(); i++) { - if (listeners_[i].get() == listener) { - listener->stop_listen(); - listeners_.erase(listeners_.begin() + i); - break; - } - } - } - - void on_result(uint64 id, tl_object_ptr<td_api::Object> result) { - on_update(std::make_shared<Update>(id, std::move(result))); - } - void on_error(uint64 id, tl_object_ptr<td_api::error> error) { - on_update(std::make_shared<Update>(id, std::move(error))); - } - void on_update(std::shared_ptr<Update> update) { - for (auto &listener : listeners_) { - listener->on_update(update); - } - do_pending_remove_listeners(); - } - - void on_closed() { - stop(); - } - - void start_up() override { - rmrf(name_); - set_context(std::make_shared<td::ActorContext>()); - set_tag(name_); - LOG(INFO) << "START UP!"; - - td_ = create_actor<ClientActor>("Td-proxy", make_td_callback()); - } - - ActorOwn<ClientActor> td_; - - string name_; - - private: - std::vector<std::unique_ptr<Listener>> listeners_; - std::vector<Listener *> pending_remove_; - - Promise<> close_promise_; -}; - -class Task : public TestClient::Listener { - public: - void on_update(std::shared_ptr<TestClient::Update> update) override { - auto it = sent_queries_.find(update->id); - if (it != sent_queries_.end()) { - it->second(std::move(update->object)); - sent_queries_.erase(it); - } - process_update(update); - } - void start_listen(TestClient *client) override { - client_ = client; - start_up(); - } - virtual void process_update(std::shared_ptr<TestClient::Update> update) { - } - - template <class F> - void send_query(tl_object_ptr<td_api::Function> function, F callback) { - auto id = current_query_id_++; - sent_queries_[id] = std::forward<F>(callback); - send_closure(client_->td_, &ClientActor::request, id, std::move(function)); - } - - protected: - std::map<uint64, std::function<void(tl_object_ptr<td_api::Object>)>> sent_queries_; - TestClient *client_; - uint64 current_query_id_ = 1; - - virtual void start_up() { - } - void stop() { - client_->remove_listener(this); - } -}; - -class DoAuthentication : public Task { - public: - DoAuthentication(string name, string phone, string code, Promise<> promise) - : name_(std::move(name)), phone_(std::move(phone)), code_(std::move(code)), promise_(std::move(promise)) { - } - void start_up() override { - send_query(make_tl_object<td_api::getAuthorizationState>(), - [this](auto res) { this->process_authorization_state(std::move(res)); }); - } - void process_authorization_state(tl_object_ptr<td_api::Object> authorization_state) { - start_flag_ = true; - tl_object_ptr<td_api::Function> function; - switch (authorization_state->get_id()) { - case td_api::authorizationStateWaitEncryptionKey::ID: - function = make_tl_object<td_api::checkDatabaseEncryptionKey>(); - break; - case td_api::authorizationStateWaitPhoneNumber::ID: - function = make_tl_object<td_api::setAuthenticationPhoneNumber>(phone_, false, true); - break; - case td_api::authorizationStateWaitCode::ID: - function = make_tl_object<td_api::checkAuthenticationCode>(code_, name_, ""); - break; - case td_api::authorizationStateWaitTdlibParameters::ID: { - auto parameters = td_api::make_object<td_api::tdlibParameters>(); - parameters->use_test_dc_ = true; - parameters->database_directory_ = name_ + TD_DIR_SLASH; - parameters->use_message_database_ = true; - parameters->use_secret_chats_ = true; - parameters->api_id_ = 94575; - parameters->api_hash_ = "a3406de8d171bb422bb6ddf3bbd800e2"; - parameters->system_language_code_ = "en"; - parameters->device_model_ = "Desktop"; - parameters->system_version_ = "Unknown"; - parameters->application_version_ = "tdclient-test"; - parameters->ignore_file_names_ = false; - parameters->enable_storage_optimizer_ = true; - function = td_api::make_object<td_api::setTdlibParameters>(std::move(parameters)); - break; - } - case td_api::authorizationStateReady::ID: - on_authorization_ready(); - return; - default: - CHECK(false) << "Unexpected authorization state " << to_string(authorization_state); - } - send_query(std::move(function), [this](auto res) { CHECK(res->get_id() == td_api::ok::ID) << to_string(res); }); - } - void on_authorization_ready() { - LOG(INFO) << "GOT AUTHORIZED"; - stop(); - } - - private: - string name_; - string phone_; - string code_; - Promise<> promise_; - bool start_flag_{false}; - void process_update(std::shared_ptr<TestClient::Update> update) override { - if (!start_flag_) { - return; - } - if (!update->object) { - return; - } - if (update->object->get_id() == td_api::updateAuthorizationState::ID) { - auto o = std::move(update->object); - process_authorization_state(std::move(static_cast<td_api::updateAuthorizationState &>(*o).authorization_state_)); - } - } -}; - -class SetUsername : public Task { - public: - SetUsername(string username, Promise<> promise) : username_(std::move(username)), promise_(std::move(promise)) { - } - - private: - string username_; - Promise<> promise_; - int32 self_id_; - string tag_; - - void start_up() override { - send_query(make_tl_object<td_api::getMe>(), [this](auto res) { this->process_me_user(std::move(res)); }); - } - - void process_me_user(tl_object_ptr<td_api::Object> res) { - CHECK(res->get_id() == td_api::user::ID); - auto user = move_tl_object_as<td_api::user>(res); - self_id_ = user->id_; - if (user->username_ != username_) { - LOG(INFO) << "SET USERNAME: " << username_; - send_query(make_tl_object<td_api::setUsername>(username_), [this](auto res) { - CHECK(res->get_id() == td_api::ok::ID); - this->send_self_message(); - }); - } else { - send_self_message(); - } - } - void send_self_message() { - tag_ = PSTRING() << format::as_hex(Random::secure_int64()); - - send_query(make_tl_object<td_api::createPrivateChat>(self_id_, false), [this](auto res) { - CHECK(res->get_id() == td_api::chat::ID); - auto chat = move_tl_object_as<td_api::chat>(res); - this->send_query( - make_tl_object<td_api::sendMessage>( - chat->id_, 0, false, false, nullptr, - make_tl_object<td_api::inputMessageText>( - make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " INIT", Auto()), false, false)), - [](auto res) {}); - }); - } - - void process_update(std::shared_ptr<TestClient::Update> update) override { - if (!update->object) { - return; - } - if (update->object->get_id() == td_api::updateMessageSendSucceeded::ID) { - auto updateNewMessage = move_tl_object_as<td_api::updateMessageSendSucceeded>(update->object); - auto &message = updateNewMessage->message_; - if (message->content_->get_id() == td_api::messageText::ID) { - auto messageText = move_tl_object_as<td_api::messageText>(message->content_); - auto text = messageText->text_->text_; - if (text.substr(0, tag_.size()) == tag_) { - LOG(INFO) << "GOT SELF MESSAGE"; - return stop(); - } - } - } - } -}; - -class CheckTestA : public Task { - public: - CheckTestA(string tag, Promise<> promise) : tag_(std::move(tag)), promise_(std::move(promise)) { - } - - private: - string tag_; - Promise<> promise_; - string previous_text_; - int cnt_ = 20; - void process_update(std::shared_ptr<TestClient::Update> update) override { - if (update->object->get_id() == td_api::updateNewMessage::ID) { - auto updateNewMessage = move_tl_object_as<td_api::updateNewMessage>(update->object); - auto &message = updateNewMessage->message_; - if (message->content_->get_id() == td_api::messageText::ID) { - auto messageText = move_tl_object_as<td_api::messageText>(message->content_); - auto text = messageText->text_->text_; - if (text.substr(0, tag_.size()) == tag_) { - CHECK(text > previous_text_) << tag("now", text) << tag("previous", previous_text_); - previous_text_ = text; - cnt_--; - LOG(INFO) << "GOT " << tag("text", text) << tag("left", cnt_); - if (cnt_ == 0) { - return stop(); - } - } - } - } - } -}; - -class TestA : public Task { - public: - TestA(string tag, string username) : tag_(std::move(tag)), username_(std::move(username)) { - } - void start_up() override { - send_query(make_tl_object<td_api::searchPublicChat>(username_), [this](auto res) { - CHECK(res->get_id() == td_api::chat::ID); - auto chat = move_tl_object_as<td_api::chat>(res); - for (int i = 0; i < 20; i++) { - this->send_query(make_tl_object<td_api::sendMessage>( - chat->id_, 0, false, false, nullptr, - make_tl_object<td_api::inputMessageText>( - make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " " << (1000 + i), Auto()), - false, false)), - [&](auto res) { this->stop(); }); - } - }); - } - - private: - string tag_; - string username_; -}; - -class TestSecretChat : public Task { - public: - TestSecretChat(string tag, string username) : tag_(std::move(tag)), username_(std::move(username)) { - } - - void start_up() override { - auto f = [this](auto res) { - CHECK(res->get_id() == td_api::chat::ID); - auto chat = move_tl_object_as<td_api::chat>(res); - this->chat_id_ = chat->id_; - this->secret_chat_id_ = move_tl_object_as<td_api::chatTypeSecret>(chat->type_)->secret_chat_id_; - }; - send_query(make_tl_object<td_api::searchPublicChat>(username_), [this, f = std::move(f)](auto res) mutable { - CHECK(res->get_id() == td_api::chat::ID); - auto chat = move_tl_object_as<td_api::chat>(res); - CHECK(chat->type_->get_id() == td_api::chatTypePrivate::ID); - auto info = move_tl_object_as<td_api::chatTypePrivate>(chat->type_); - this->send_query(make_tl_object<td_api::createNewSecretChat>(info->user_id_), std::move(f)); - }); - } - - void process_update(std::shared_ptr<TestClient::Update> update) override { - if (!update->object) { - return; - } - if (update->object->get_id() == td_api::updateSecretChat::ID) { - auto update_secret_chat = move_tl_object_as<td_api::updateSecretChat>(update->object); - if (update_secret_chat->secret_chat_->id_ != secret_chat_id_ || - update_secret_chat->secret_chat_->state_->get_id() != td_api::secretChatStateReady::ID) { - return; - } - LOG(INFO) << "SEND ENCRYPTED MESSAGES"; - for (int i = 0; i < 20; i++) { - send_query(make_tl_object<td_api::sendMessage>( - chat_id_, 0, false, false, nullptr, - make_tl_object<td_api::inputMessageText>( - make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " " << (1000 + i), Auto()), false, - false)), - [](auto res) {}); - } - } - } - - private: - string tag_; - string username_; - int64 secret_chat_id_ = 0; - int64 chat_id_ = 0; -}; - -class TestFileGenerated : public Task { - public: - TestFileGenerated(string tag, string username) : tag_(std::move(tag)), username_(std::move(username)) { - } - - void start_up() override { - } - - void process_update(std::shared_ptr<TestClient::Update> update) override { - if (!update->object) { - return; - } - if (update->object->get_id() == td_api::updateNewMessage::ID) { - auto updateNewMessage = move_tl_object_as<td_api::updateNewMessage>(update->object); - auto &message = updateNewMessage->message_; - chat_id_ = message->chat_id_; - if (message->content_->get_id() == td_api::messageText::ID) { - auto messageText = move_tl_object_as<td_api::messageText>(message->content_); - auto text = messageText->text_->text_; - if (text.substr(0, tag_.size()) == tag_) { - if (text.substr(tag_.size() + 1) == "ONE_FILE") { - return one_file(); - } - } - } - } else if (update->object->get_id() == td_api::updateFileGenerationStart::ID) { - auto info = move_tl_object_as<td_api::updateFileGenerationStart>(update->object); - generate_file(info->generation_id_, info->original_path_, info->destination_path_, info->conversion_); - } else if (update->object->get_id() == td_api::updateFile::ID) { - auto file = move_tl_object_as<td_api::updateFile>(update->object); - LOG(INFO) << to_string(file); - } - } - void one_file() { - LOG(ERROR) << "Start ONE_FILE test"; - string file_path = string("test_documents") + TD_DIR_SLASH + "a.txt"; - mkpath(file_path).ensure(); - auto raw_file = - FileFd::open(file_path, FileFd::Flags::Create | FileFd::Flags::Truncate | FileFd::Flags::Write).move_as_ok(); - auto file = BufferedFd<FileFd>(std::move(raw_file)); - for (int i = 1; i < 100000; i++) { - file.write(PSLICE() << i << "\n").ensure(); - } - file.flush_write().ensure(); // important - file.close(); - this->send_query(make_tl_object<td_api::sendMessage>( - chat_id_, 0, false, false, nullptr, - make_tl_object<td_api::inputMessageDocument>( - make_tl_object<td_api::inputFileGenerated>(file_path, "square", 0), - make_tl_object<td_api::inputThumbnail>( - make_tl_object<td_api::inputFileGenerated>(file_path, "thumbnail", 0), 0, 0), - make_tl_object<td_api::formattedText>(tag_, Auto()))), - [](auto res) { check_td_error(res); }); - - this->send_query( - make_tl_object<td_api::sendMessage>(chat_id_, 0, false, false, nullptr, - make_tl_object<td_api::inputMessageDocument>( - make_tl_object<td_api::inputFileGenerated>(file_path, "square", 0), - nullptr, make_tl_object<td_api::formattedText>(tag_, Auto()))), - [](auto res) { check_td_error(res); }); - } - - friend class GenerateFile; - class GenerateFile : public Actor { - public: - GenerateFile(Task *parent, int64 id, string original_path, string destination_path, string conversion) - : parent_(parent) - , id_(id) - , original_path_(std::move(original_path)) - , destination_path_(std::move(destination_path)) - , conversion_(std::move(conversion)) { - } - - private: - Task *parent_; - int64 id_; - string original_path_; - string destination_path_; - string conversion_; - - FILE *from = nullptr; - FILE *to = nullptr; - - void start_up() override { - from = std::fopen(original_path_.c_str(), "rb"); - CHECK(from); - to = std::fopen(destination_path_.c_str(), "wb"); - CHECK(to); - yield(); - } - void loop() override { - int cnt = 0; - while (true) { - uint32 x; - auto r = std::fscanf(from, "%u", &x); - if (r != 1) { - return stop(); - } - std::fprintf(to, "%u\n", x * x); - if (++cnt >= 10000) { - break; - } - } - auto ready = std::ftell(to); - LOG(ERROR) << "READY: " << ready; - parent_->send_query(make_tl_object<td_api::setFileGenerationProgress>( - id_, 1039823 /*yeah, exact size of this file*/, narrow_cast<int32>(ready)), - [](auto result) { check_td_error(result); }); - set_timeout_in(0.02); - } - void tear_down() override { - std::fclose(from); - std::fclose(to); - parent_->send_query(make_tl_object<td_api::finishFileGeneration>(id_, nullptr), - [](auto result) { check_td_error(result); }); - } - }; - void generate_file(int64 id, string original_path, string destination_path, string conversion) { - LOG(ERROR) << "Generate file " << tag("id", id) << tag("original_path", original_path) - << tag("destination_path", destination_path) << tag("conversion", conversion); - if (conversion == "square") { - create_actor<GenerateFile>("GenerateFile", this, id, original_path, destination_path, conversion).release(); - } else if (conversion == "thumbnail") { - write_file(destination_path, base64url_decode(Slice(thumbnail, thumbnail_size)).ok()).ensure(); - this->send_query(make_tl_object<td_api::finishFileGeneration>(id, nullptr), - [](auto result) { check_td_error(result); }); - } else { - LOG(FATAL) << "unknown " << tag("conversion", conversion); - } - } - - private: - string tag_; - string username_; - int64 chat_id_ = 0; -}; - -class CheckTestC : public Task { - public: - CheckTestC(string username, string tag, Promise<> promise) - : username_(std::move(username)), tag_(std::move(tag)), promise_(std::move(promise)) { - } - - void start_up() override { - send_query(make_tl_object<td_api::searchPublicChat>(username_), [this](auto res) { - CHECK(res->get_id() == td_api::chat::ID); - auto chat = move_tl_object_as<td_api::chat>(res); - chat_id_ = chat->id_; - this->one_file(); - }); - } - - private: - string username_; - string tag_; - Promise<> promise_; - int64 chat_id_; - - void one_file() { - this->send_query( - make_tl_object<td_api::sendMessage>( - chat_id_, 0, false, false, nullptr, - make_tl_object<td_api::inputMessageText>( - make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " ONE_FILE", Auto()), false, false)), - [](auto res) { check_td_error(res); }); - } - - void process_update(std::shared_ptr<TestClient::Update> update) override { - if (!update->object) { - return; - } - if (update->object->get_id() == td_api::updateNewMessage::ID) { - auto updateNewMessage = move_tl_object_as<td_api::updateNewMessage>(update->object); - auto &message = updateNewMessage->message_; - if (message->content_->get_id() == td_api::messageDocument::ID) { - auto messageDocument = move_tl_object_as<td_api::messageDocument>(message->content_); - auto text = messageDocument->caption_->text_; - if (text.substr(0, tag_.size()) == tag_) { - file_id_to_check_ = messageDocument->document_->document_->id_; - LOG(ERROR) << "GOT FILE " << to_string(messageDocument->document_->document_); - this->send_query(make_tl_object<td_api::downloadFile>(file_id_to_check_, 1), - [](auto res) { check_td_error(res); }); - } - } - } else if (update->object->get_id() == td_api::updateFile::ID) { - auto updateFile = move_tl_object_as<td_api::updateFile>(update->object); - if (updateFile->file_->id_ == file_id_to_check_ && (updateFile->file_->local_->is_downloading_completed_)) { - check_file(updateFile->file_->local_->path_); - } - } - } - - void check_file(CSlice path) { - FILE *from = std::fopen(path.c_str(), "rb"); - CHECK(from); - uint32 x; - uint32 y = 1; - while (std::fscanf(from, "%u", &x) == 1) { - CHECK(x == y * y); - y++; - } - std::fclose(from); - stop(); - } - int32 file_id_to_check_ = 0; -}; - -class LoginTestActor : public Actor { - public: - explicit LoginTestActor(Status *status) : status_(status) { - *status_ = Status::OK(); - } - - private: - Status *status_; - ActorOwn<TestClient> alice_; - ActorOwn<TestClient> bob_; - - string alice_phone_ = "9996636437"; - string bob_phone_ = "9996636438"; - string alice_username_ = "alice_" + alice_phone_; - string bob_username_ = "bob_" + bob_phone_; - - string stage_name_; - - void begin_stage(string stage_name, double timeout) { - LOG(WARNING) << "Begin stage '" << stage_name << "'"; - stage_name_ = std::move(stage_name); - set_timeout_in(timeout); - } - - void start_up() override { - begin_stage("Logging in", 160); - alice_ = create_actor<TestClient>("AliceClient", "alice"); - bob_ = create_actor<TestClient>("BobClient", "bob"); - - send_closure(alice_, &TestClient::add_listener, - std::make_unique<DoAuthentication>( - "alice", alice_phone_, "33333", - PromiseCreator::event(self_closure(this, &LoginTestActor::start_up_fence_dec)))); - - send_closure(bob_, &TestClient::add_listener, - std::make_unique<DoAuthentication>( - "bob", bob_phone_, "33333", - PromiseCreator::event(self_closure(this, &LoginTestActor::start_up_fence_dec)))); - } - - int start_up_fence_ = 3; - void start_up_fence_dec() { - --start_up_fence_; - if (start_up_fence_ == 0) { - init(); - } else if (start_up_fence_ == 1) { - return init(); - class WaitActor : public Actor { - public: - WaitActor(double timeout, Promise<> promise) : timeout_(timeout), promise_(std::move(promise)) { - } - void start_up() override { - set_timeout_in(timeout_); - } - void timeout_expired() override { - stop(); - } - - private: - double timeout_; - Promise<> promise_; - }; - create_actor<WaitActor>("WaitActor", 2, - PromiseCreator::event(self_closure(this, &LoginTestActor::start_up_fence_dec))) - .release(); - } - } - - void init() { - send_closure(alice_, &TestClient::add_listener, - std::make_unique<SetUsername>( - alice_username_, PromiseCreator::event(self_closure(this, &LoginTestActor::init_fence_dec)))); - send_closure(bob_, &TestClient::add_listener, - std::make_unique<SetUsername>( - bob_username_, PromiseCreator::event(self_closure(this, &LoginTestActor::init_fence_dec)))); - } - - int init_fence_ = 2; - void init_fence_dec() { - if (--init_fence_ == 0) { - test_a(); - } - } - - int32 test_a_fence_ = 2; - void test_a_fence() { - if (--test_a_fence_ == 0) { - test_b(); - } - } - - void test_a() { - begin_stage("Ready to create chats", 80); - string alice_tag = PSTRING() << format::as_hex(Random::secure_int64()); - string bob_tag = PSTRING() << format::as_hex(Random::secure_int64()); - - send_closure(bob_, &TestClient::add_listener, - std::make_unique<CheckTestA>( - alice_tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_a_fence)))); - send_closure(alice_, &TestClient::add_listener, - std::make_unique<CheckTestA>( - bob_tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_a_fence)))); - - send_closure(alice_, &TestClient::add_listener, std::make_unique<TestA>(alice_tag, bob_username_)); - send_closure(bob_, &TestClient::add_listener, std::make_unique<TestA>(bob_tag, alice_username_)); - // send_closure(alice_, &TestClient::add_listener, std::make_unique<TestChat>(bob_username_)); - } - - void timeout_expired() override { - LOG(FATAL) << "Timeout expired in stage '" << stage_name_ << "'"; - } - - int32 test_b_fence_ = 1; - void test_b_fence() { - if (--test_b_fence_ == 0) { - test_c(); - } - } - - int32 test_c_fence_ = 1; - void test_c_fence() { - if (--test_c_fence_ == 0) { - finish(); - } - } - - void test_b() { - begin_stage("Create secret chat", 40); - string tag = PSTRING() << format::as_hex(Random::secure_int64()); - - send_closure( - bob_, &TestClient::add_listener, - std::make_unique<CheckTestA>(tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_b_fence)))); - send_closure(alice_, &TestClient::add_listener, std::make_unique<TestSecretChat>(tag, bob_username_)); - } - - void test_c() { - begin_stage("Send generated file", 240); - string tag = PSTRING() << format::as_hex(Random::secure_int64()); - - send_closure(bob_, &TestClient::add_listener, - std::make_unique<CheckTestC>( - alice_username_, tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_c_fence)))); - send_closure(alice_, &TestClient::add_listener, std::make_unique<TestFileGenerated>(tag, bob_username_)); - } - - int32 finish_fence_ = 2; - void finish_fence() { - finish_fence_--; - if (finish_fence_ == 0) { - Scheduler::instance()->finish(); - stop(); - } - } - void finish() { - send_closure(alice_, &TestClient::close, PromiseCreator::event(self_closure(this, &LoginTestActor::finish_fence))); - send_closure(bob_, &TestClient::close, PromiseCreator::event(self_closure(this, &LoginTestActor::finish_fence))); - } -}; - -class Tdclient_login : public td::Test { - public: - using Test::Test; - bool step() final { - if (!is_inited_) { - SET_VERBOSITY_LEVEL(VERBOSITY_NAME(DEBUG) + 2); - sched_.init(4); - sched_.create_actor_unsafe<LoginTestActor>(0, "LoginTestActor", &result_).release(); - sched_.start(); - is_inited_ = true; - } - - bool ret = sched_.run_main(10); - if (ret) { - return true; - } - sched_.finish(); - if (result_.is_error()) { - LOG(ERROR) << result_; - } - ASSERT_TRUE(result_.is_ok()); - return false; - } - - private: - bool is_inited_ = false; - ConcurrentScheduler sched_; - Status result_; -}; -Tdclient_login Tdclient_login("Tdclient_login"); -}; // namespace td |