blob: 087ed1ac80e8214acce31d3acf52c9decf1ce742 [file] [log] [blame]
// Copyright 2022 The Chromium 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 "test/test_base.h"
#include <chrono>
#include <thread>
#include "api.h"
#include "ipcz/ipcz.h"
#include "ipcz/portal.h"
#include "ipcz/router.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/synchronization/notification.h"
#include "util/ref_counted.h"
namespace ipcz::test::internal {
namespace {
void CreateNodeChecked(const IpczAPI& ipcz,
const IpczDriver& driver,
IpczCreateNodeFlags flags,
IpczHandle& handle) {
const IpczResult result = ipcz.CreateNode(&driver, IPCZ_INVALID_DRIVER_HANDLE,
flags, nullptr, &handle);
ASSERT_EQ(IPCZ_RESULT_OK, result);
}
void OpenPortalsChecked(const IpczAPI& ipcz,
IpczHandle node,
IpczHandle& first,
IpczHandle& second) {
const IpczResult result =
ipcz.OpenPortals(node, IPCZ_NO_FLAGS, nullptr, &first, &second);
ASSERT_EQ(IPCZ_RESULT_OK, result);
}
} // namespace
TestBase::TestBase() {
IpczGetAPI(&ipcz_);
}
TestBase::~TestBase() = default;
void TestBase::Close(IpczHandle handle) {
ASSERT_EQ(IPCZ_RESULT_OK, ipcz().Close(handle, IPCZ_NO_FLAGS, nullptr));
}
void TestBase::CloseAll(absl::Span<const IpczHandle> handles) {
for (IpczHandle handle : handles) {
Close(handle);
}
}
IpczResult TestBase::Merge(IpczHandle a, IpczHandle b) {
return ipcz().MergePortals(a, b, IPCZ_NO_FLAGS, nullptr);
}
IpczHandle TestBase::CreateNode(const IpczDriver& driver,
IpczCreateNodeFlags flags) {
IpczHandle node;
CreateNodeChecked(ipcz(), driver, flags, node);
return node;
}
std::pair<IpczHandle, IpczHandle> TestBase::OpenPortals(IpczHandle node) {
IpczHandle a, b;
OpenPortalsChecked(ipcz(), node, a, b);
return {a, b};
}
IpczResult TestBase::Put(IpczHandle portal,
std::string_view message,
absl::Span<IpczHandle> handles) {
return ipcz().Put(portal, message.data(), message.size(), handles.data(),
handles.size(), IPCZ_NO_FLAGS, nullptr);
}
IpczResult TestBase::PutWithLimits(IpczHandle portal,
const IpczPutLimits& limits,
std::string_view message,
absl::Span<IpczHandle> handles) {
IpczPutLimits sized_limits = limits;
sized_limits.size = sizeof(sized_limits);
const IpczPutOptions options = {
.size = sizeof(options),
.limits = &sized_limits,
};
return ipcz().Put(portal, message.data(), message.size(), handles.data(),
handles.size(), IPCZ_NO_FLAGS, &options);
}
IpczResult TestBase::Get(IpczHandle portal,
std::string* message,
absl::Span<IpczHandle> handles) {
if (message) {
message->clear();
}
size_t num_bytes = 0;
IpczHandle* handle_storage = handles.empty() ? nullptr : handles.data();
size_t num_handles = handles.size();
IpczResult result = ipcz().Get(portal, IPCZ_NO_FLAGS, nullptr, nullptr,
&num_bytes, handle_storage, &num_handles);
if (result != IPCZ_RESULT_RESOURCE_EXHAUSTED) {
return result;
}
void* data_storage = nullptr;
if (message) {
message->resize(num_bytes);
data_storage = message->data();
}
return ipcz().Get(portal, IPCZ_NO_FLAGS, nullptr, data_storage, &num_bytes,
handle_storage, &num_handles);
}
IpczResult TestBase::Trap(IpczHandle portal,
const IpczTrapConditions& conditions,
TrapEventHandler fn,
IpczTrapConditionFlags* flags,
IpczPortalStatus* status) {
auto handler = std::make_unique<TrapEventHandler>(std::move(fn));
auto context = reinterpret_cast<uintptr_t>(handler.get());
// For convenience, set the `size` field correctly so callers don't have to.
IpczTrapConditions sized_conditions = conditions;
sized_conditions.size = sizeof(sized_conditions);
const IpczResult result =
ipcz().Trap(portal, &sized_conditions, &HandleEvent, context,
IPCZ_NO_FLAGS, nullptr, flags, status);
if (result == IPCZ_RESULT_OK) {
std::ignore = handler.release();
}
return result;
}
IpczResult TestBase::WaitForConditions(IpczHandle portal,
const IpczTrapConditions& conditions) {
absl::Notification notification;
const IpczResult result = Trap(
portal, conditions, [&](const IpczTrapEvent&) { notification.Notify(); });
switch (result) {
case IPCZ_RESULT_OK:
notification.WaitForNotification();
return IPCZ_RESULT_OK;
case IPCZ_RESULT_FAILED_PRECONDITION:
return IPCZ_RESULT_OK;
default:
return result;
}
}
IpczResult TestBase::WaitForConditionFlags(IpczHandle portal,
IpczTrapConditionFlags flags) {
const IpczTrapConditions conditions = {
.size = sizeof(conditions),
.flags = flags,
};
return WaitForConditions(portal, conditions);
}
IpczResult TestBase::WaitToGet(IpczHandle portal,
std::string* message,
absl::Span<IpczHandle> handles) {
const IpczTrapConditions conditions = {
.size = sizeof(conditions),
.flags = IPCZ_TRAP_ABOVE_MIN_LOCAL_PARCELS,
.min_local_parcels = 0,
};
IpczResult result = WaitForConditions(portal, conditions);
if (result != IPCZ_RESULT_OK) {
return result;
}
return Get(portal, message, handles);
}
void TestBase::PingPong(IpczHandle portal) {
EXPECT_EQ(IPCZ_RESULT_OK, Put(portal, {}));
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(portal));
}
void TestBase::WaitForPingAndReply(IpczHandle portal) {
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(portal));
EXPECT_EQ(IPCZ_RESULT_OK, Put(portal, {}));
}
void TestBase::VerifyEndToEnd(IpczHandle portal) {
static const char kTestMessage[] = "Ping!!!";
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, Put(portal, kTestMessage));
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(portal, &message));
EXPECT_EQ(kTestMessage, message);
}
void TestBase::VerifyEndToEndLocal(IpczHandle a, IpczHandle b) {
const std::string kMessage1 = "psssst";
const std::string kMessage2 = "ssshhh";
Put(a, kMessage1);
Put(b, kMessage2);
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(a, &message));
EXPECT_EQ(kMessage2, message);
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, &message));
EXPECT_EQ(kMessage1, message);
}
void TestBase::WaitForDirectRemoteLink(IpczHandle portal) {
const Ref<Router> router = Portal::FromHandle(portal)->router();
while (!router->IsOnCentralRemoteLink()) {
using namespace std::chrono_literals;
std::this_thread::sleep_for(8ms);
}
const std::string kMessage = "very direct wow";
EXPECT_EQ(IPCZ_RESULT_OK, Put(portal, kMessage));
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(portal, &message));
EXPECT_EQ(kMessage, message);
}
void TestBase::WaitForDirectLocalLink(IpczHandle a, IpczHandle b) {
const Ref<Router> router_a = Portal::FromHandle(a)->router();
const Ref<Router> router_b = Portal::FromHandle(b)->router();
while (!router_a->HasLocalPeer(*router_b) &&
!router_b->HasLocalPeer(*router_a)) {
using namespace std::chrono_literals;
std::this_thread::sleep_for(8ms);
}
}
void TestBase::HandleEvent(const IpczTrapEvent* event) {
auto handler =
absl::WrapUnique(reinterpret_cast<TrapEventHandler*>(event->context));
(*handler)(*event);
}
} // namespace ipcz::test::internal