cef/tests/ceftests/message_router_threshold_un...

231 lines
6.8 KiB
C++
Raw Normal View History

// 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 CharType>
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 =
"<html><body><script>\n"
// Send the query.
"var request_id = window." +
std::string(kJSQueryFunc) + "({\n request: '" +
std::to_string(string_length_) +
"',\n persistent: false,\n"
" onSuccess: function(response) {\n"
" window.mrtNotify(response);\n"
" },\n"
" onFailure: function(error_code, error_message) {\n"
" if (error_code == " +
errorCodeStr +
")\n"
" window.mrtNotify(error_message);\n"
" else\n"
" window.mrtNotify('error-onFailure');\n"
" }\n"
"});\n</script></body></html>";
return html;
}
void OnNotify(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> 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<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int64_t query_id,
const CefString& request,
bool persistent,
CefRefPtr<Callback> 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<size_t>(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> callback_;
TrackCallback got_on_query_;
TrackCallback got_notify_;
};
using CharTestHandler = ThresholdTestHandler<char>;
using CharTestHandlerPtr = CefRefPtr<CharTestHandler>;
using WCharTestHandler = ThresholdTestHandler<wchar_t>;
using WCharTestHandlerPtr = CefRefPtr<WCharTestHandler>;
} // 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);
}