// Copyright (c) 2022 The Chromium Embedded Framework Authors. All rights // reserved. Use of this source code is governed by a BSD-style license that // can be found in the LICENSE file. #include "tests/ceftests/message_router_unittest_utils.h" namespace { constexpr int kSingleQueryErrorCode = 5; constexpr size_t kMsgSizeThresholdInBytes = 16000; constexpr auto kCharSize = sizeof(CefString::char_type); enum class TestType { SUCCESS, FAILURE }; CefString GenerateResponse(size_t count, char ch) { return std::string(count, ch); } CefString GenerateResponse(size_t count, wchar_t ch) { return std::wstring(count, ch); } template class ThresholdTestHandler final : public SingleLoadTestHandler { public: ThresholdTestHandler(TestType type, size_t string_length, CharType symbol) : test_type_(type), string_length_(string_length), symbol_(symbol) {} std::string GetMainHTML() override { const std::string& errorCodeStr = std::to_string(kSingleQueryErrorCode); std::string html = ""; return html; } void OnNotify(CefRefPtr browser, CefRefPtr frame, const std::string& message) override { AssertMainBrowser(browser); AssertMainFrame(frame); // OnNotify only be called once. EXPECT_FALSE(got_notify_); got_notify_.yes(); auto expected = GenerateResponse(string_length_, symbol_); switch (test_type_) { case TestType::SUCCESS: EXPECT_EQ(expected, message); break; case TestType::FAILURE: EXPECT_EQ(expected, message); break; default: ADD_FAILURE(); break; } DestroyTest(); } void ExecuteCallback(size_t response_size) { auto response = GenerateResponse(response_size, symbol_); EXPECT_TRUE(callback_.get()); switch (test_type_) { case TestType::SUCCESS: callback_->Success(response); break; case TestType::FAILURE: callback_->Failure(kSingleQueryErrorCode, response); break; default: ADD_FAILURE(); break; } callback_ = nullptr; } bool OnQuery(CefRefPtr browser, CefRefPtr frame, int64_t query_id, const CefString& request, bool persistent, CefRefPtr callback) override { AssertMainBrowser(browser); AssertMainFrame(frame); EXPECT_NE(0, query_id); EXPECT_FALSE(persistent); EXPECT_EQ(std::to_string(string_length_), request.ToString()); const size_t message_size = static_cast(std::stoi(request.ToString())); got_on_query_.yes(); callback_ = callback; ExecuteCallback(message_size); return true; } void DestroyTest() override { EXPECT_TRUE(got_notify_); EXPECT_TRUE(got_on_query_); EXPECT_FALSE(callback_.get()); TestHandler::DestroyTest(); } private: const TestType test_type_; const size_t string_length_; const CharType symbol_; CefRefPtr callback_; TrackCallback got_on_query_; TrackCallback got_notify_; }; using CharTestHandler = ThresholdTestHandler; using CharTestHandlerPtr = CefRefPtr; using WCharTestHandler = ThresholdTestHandler; using WCharTestHandlerPtr = CefRefPtr; } // namespace TEST(MessageRouterTest, ThresholdMessageUnderSuccessCallback) { const auto under_threshold = kMsgSizeThresholdInBytes - kCharSize; const auto string_length = under_threshold / kCharSize; CharTestHandlerPtr handler = new CharTestHandler(TestType::SUCCESS, string_length, 'A'); handler->SetMessageSizeThreshold(kMsgSizeThresholdInBytes); handler->ExecuteTest(); ReleaseAndWaitForDestructor(handler); } TEST(MessageRouterTest, ThresholdMessageExactSuccessCallback) { const auto string_length = kMsgSizeThresholdInBytes / kCharSize; CharTestHandlerPtr handler = new CharTestHandler(TestType::SUCCESS, string_length, 'A'); handler->SetMessageSizeThreshold(kMsgSizeThresholdInBytes); handler->ExecuteTest(); ReleaseAndWaitForDestructor(handler); } TEST(MessageRouterTest, ThresholdMessageOverSuccessCallback) { const auto over_threshold = kMsgSizeThresholdInBytes + kCharSize; const auto string_length = over_threshold / kCharSize; CharTestHandlerPtr handler = new CharTestHandler(TestType::SUCCESS, string_length, 'A'); handler->SetMessageSizeThreshold(kMsgSizeThresholdInBytes); handler->ExecuteTest(); ReleaseAndWaitForDestructor(handler); } TEST(MessageRouterTest, ThresholdMessageUnderFailureCallback) { const auto under_threshold = kMsgSizeThresholdInBytes - kCharSize; const auto string_length = under_threshold / kCharSize; CharTestHandlerPtr handler = new CharTestHandler(TestType::FAILURE, string_length, 'A'); handler->SetMessageSizeThreshold(kMsgSizeThresholdInBytes); handler->ExecuteTest(); ReleaseAndWaitForDestructor(handler); } TEST(MessageRouterTest, ThresholdMessageOverFailureCallback) { const auto over_threshold = kMsgSizeThresholdInBytes + kCharSize; const auto string_length = over_threshold / kCharSize; CharTestHandlerPtr handler = new CharTestHandler(TestType::FAILURE, string_length, 'A'); handler->SetMessageSizeThreshold(kMsgSizeThresholdInBytes); handler->ExecuteTest(); ReleaseAndWaitForDestructor(handler); } TEST(MessageRouterTest, ThresholdUtf8MessageUnderSuccessCallback) { const auto under_threshold = kMsgSizeThresholdInBytes - kCharSize; const auto string_length = under_threshold / kCharSize; WCharTestHandlerPtr handler = new WCharTestHandler(TestType::SUCCESS, string_length, L'\u304B'); handler->SetMessageSizeThreshold(kMsgSizeThresholdInBytes); handler->ExecuteTest(); ReleaseAndWaitForDestructor(handler); } TEST(MessageRouterTest, ThresholdUtf8MessageOverSuccessCallback) { const auto over_threshold = kMsgSizeThresholdInBytes + kCharSize; const auto string_length = over_threshold / kCharSize; WCharTestHandlerPtr handler = new WCharTestHandler(TestType::SUCCESS, string_length, L'\u304B'); handler->SetMessageSizeThreshold(kMsgSizeThresholdInBytes); handler->ExecuteTest(); ReleaseAndWaitForDestructor(handler); }