components/exo/wayland/wayland_protocol_logger_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2024 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "components/exo/wayland/wayland_protocol_logger.h"

 #include <wayland-server-core.h>
 #include <wayland-util.h>
 #include <xdg-shell-client-protocol.h>
 #include <xdg-shell-server-protocol.h>

 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/exo/wayland/test/client_util.h"
 #include "components/exo/wayland/test/resource_key.h"
 #include "components/exo/wayland/test/server_util.h"
 #include "components/exo/wayland/test/wayland_server_test.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace exo::wayland {
 namespace {

 class WaylandProtocolLoggerTest : public test::WaylandServerTest {
  public:
   WaylandProtocolLoggerTest() = default;
   WaylandProtocolLoggerTest(const WaylandProtocolLoggerTest&) = delete;
   WaylandProtocolLoggerTest& operator=(const WaylandProtocolLoggerTest&) =
       delete;
   ~WaylandProtocolLoggerTest() override = default;

   // test::WaylandServerTest:
   void SetUp() override {
     WaylandProtocolLogger::SetHandlerFuncForTesting(
         [](void* user_data, wl_protocol_logger_type type,
            const wl_protocol_logger_message* message) {
           messages_.push_back(
               WaylandProtocolLogger::FormatMessage(type, message));
         });
     test::WaylandServerTest::SetUp();

     // Ignore messages from this test case's setup phase.
     messages_.clear();
   }

   // test::WaylandServerTest:
   void TearDown() override {
     messages_.clear();
     test::WaylandServerTest::TearDown();
   }

   static std::vector<std::vector<std::string>> messages_;
 };

 std::vector<std::vector<std::string>> WaylandProtocolLoggerTest::messages_ = {};

 class ClientData : public test::TestClient::CustomData {
  public:
   ClientData()
       : callback(nullptr, &wl_callback_destroy),
         data_source(nullptr, &wl_data_source_destroy),
         pointer(nullptr, &wl_pointer_destroy),
         surface(nullptr, &wl_surface_destroy),
         xdg_surface(nullptr, &xdg_surface_destroy),
         xdg_toplevel(nullptr, &xdg_toplevel_destroy) {}
   ~ClientData() override = default;

   std::unique_ptr<wl_callback, decltype(&wl_callback_destroy)> callback;
   std::unique_ptr<wl_data_source, decltype(&wl_data_source_destroy)>
       data_source;
   std::unique_ptr<wl_pointer, decltype(&wl_pointer_destroy)> pointer;
   std::unique_ptr<wl_surface, decltype(&wl_surface_destroy)> surface;
   std::unique_ptr<xdg_surface, decltype(&xdg_surface_destroy)> xdg_surface;
   std::unique_ptr<xdg_toplevel, decltype(&xdg_toplevel_destroy)> xdg_toplevel;
 };

 std::string ProxyId(void* proxy) {
   return base::NumberToString(
       wl_proxy_get_id(reinterpret_cast<wl_proxy*>(proxy)));
 }

 void AddState(wl_array* states, xdg_toplevel_state state) {
   xdg_toplevel_state* value = static_cast<xdg_toplevel_state*>(
       wl_array_add(states, sizeof(xdg_toplevel_state)));
   DCHECK(value);
   *value = state;
 }

 }  // namespace

 TEST_F(WaylandProtocolLoggerTest, LogsBasicRequest) {
   std::string surface_id;
   std::string compositor_id;

   PostToClientAndWait([&](test::TestClient* client) {
     auto* data = client->set_data(std::make_unique<ClientData>());
     data->surface.reset(wl_compositor_create_surface(client->compositor()));
     compositor_id = ProxyId(client->compositor());
     surface_id = ProxyId(data->surface.get());
   });

   EXPECT_THAT(messages_,
               ::testing::Contains(::testing::ElementsAre(
                   base::StrCat({"Received request: wl_compositor@",
                                 compositor_id, ".create_surface"}),
                   base::StrCat({"new id wl_surface@", surface_id}))));
 }

 TEST_F(WaylandProtocolLoggerTest, LogsBasicEvent) {
   std::string callback_id;

   EXPECT_THAT(messages_, ::testing::IsEmpty());

   PostToClientAndWait([&](test::TestClient* client) {
     auto* data = client->set_data(std::make_unique<ClientData>());
     data->callback.reset(wl_display_sync(client->display()));
     callback_id = ProxyId(data->callback.get());
   });

   EXPECT_THAT(messages_,
               ::testing::Contains(::testing::Contains(base::StrCat(
                   {"Sent event: wl_callback@", callback_id, ".done"}))));
 }

 TEST_F(WaylandProtocolLoggerTest, LogsObjects) {
   std::string xdg_wm_base_id;
   std::string xdg_surface_id;
   std::string surface_id;

   PostToClientAndWait([&](test::TestClient* client) {
     auto* data = client->set_data(std::make_unique<ClientData>());
     xdg_wm_base_id = ProxyId(client->xdg_wm_base());
     data->surface.reset(wl_compositor_create_surface(client->compositor()));
     data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
                                                         data->surface.get()));
     surface_id = ProxyId(data->surface.get());
     xdg_surface_id = ProxyId(data->xdg_surface.get());
   });

   EXPECT_THAT(messages_,
               ::testing::Contains(::testing::ElementsAre(
                   base::StrCat({"Received request: xdg_wm_base@",
                                 xdg_wm_base_id, ".get_xdg_surface"}),
                   base::StrCat({"new id xdg_surface@", xdg_surface_id}),
                   base::StrCat({"wl_surface@", surface_id}))));
 }

 TEST_F(WaylandProtocolLoggerTest, LogsStrings) {
   constexpr const char* window_title = "🦄🌈 I ♥️ UTF-8 😋";
   std::string xdg_toplevel_id;

   PostToClientAndWait([&](test::TestClient* client) {
     auto* data = client->set_data(std::make_unique<ClientData>());
     data->surface.reset(wl_compositor_create_surface(client->compositor()));
     data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
                                                         data->surface.get()));
     data->xdg_toplevel.reset(xdg_surface_get_toplevel(data->xdg_surface.get()));
     xdg_toplevel_set_title(data->xdg_toplevel.get(), window_title);
     xdg_toplevel_id = ProxyId(data->xdg_toplevel.get());
   });

   EXPECT_THAT(messages_, ::testing::Contains(::testing::ElementsAre(
                              base::StrCat({"Received request: xdg_toplevel@",
                                            xdg_toplevel_id, ".set_title"}),
                              window_title)));
 }

 // TODO(b/335767378): triggers dangling pointer detection.
 TEST_F(WaylandProtocolLoggerTest, DISABLED_LogsObjectsAndStrings) {
   std::string display_id;
   constexpr uint32_t fake_error_code = 0x12345678u;
   constexpr const char* fake_error = "🦄🌈 Fake error 😋";
   EXPECT_THAT(messages_, ::testing::IsEmpty());

   PostToClientAndWait([&](test::TestClient* client) {
     wl_resource_post_error(test::server_util::LookUpResource(
                                server_.get(), test::client_util::GetResourceKey(
                                                   client->display())),
                            fake_error_code, "%s", fake_error);
     display_id = ProxyId(client->display());
   });

   EXPECT_THAT(
       messages_,
       ::testing::Contains(::testing::ElementsAre(
           base::StrCat({"Sent event: wl_display@", display_id, ".error"}),
           base::StrCat({"wl_display@", display_id}),
           base::NumberToString(fake_error_code), fake_error)));
 }

 TEST_F(WaylandProtocolLoggerTest, LogsFileDescriptors) {
   std::string data_source_id;
   test::ResourceKey data_source_resource_key;

   PostToClientAndWait([&](test::TestClient* client) {
     auto* data = client->set_data(std::make_unique<ClientData>());
     data->data_source.reset(wl_data_device_manager_create_data_source(
         client->data_device_manager()));
     data_source_id = ProxyId(data->data_source.get());
     data_source_resource_key =
         test::client_util::GetResourceKey(data->data_source.get());
   });

   wl_resource* data_source_resource = test::server_util::LookUpResource(
       server_.get(), data_source_resource_key);
   EXPECT_NE(data_source_resource, nullptr);

   // Actually sending a wl_data_source::send event requires a valid file
   // descriptor, which requires some ceremony to set up properly.
   // Instead, call the message formatting utility directly.
   const struct wl_interface* arg_types[2] = {nullptr, nullptr};
   wl_message message = {
       .name = "send", .signature = "sh", .types = &arg_types[0]};
   wl_argument args[] = {{.s = "text/plain"}, {.h = 12345}};
   wl_protocol_logger_message logger_message = {
       .resource = data_source_resource,
       .message_opcode = WL_DATA_SOURCE_SEND,
       .message = &message,
       .arguments_count = 2,
       .arguments = &args[0],
   };

   auto result = WaylandProtocolLogger::FormatMessage(WL_PROTOCOL_LOGGER_EVENT,
                                                      &logger_message);
   EXPECT_THAT(result, ::testing::ElementsAre(
                           base::StrCat({"Sent event: wl_data_source@",
                                         data_source_id, ".send"}),
                           "text/plain", "fd 12345"));
 }

 TEST_F(WaylandProtocolLoggerTest, LogsFixedPointNumbers) {
   // Arrange: Create a wl_pointer client object, wait for server to receive.
   std::string pointer_id;
   test::ResourceKey pointer_resource_key;

   PostToClientAndWait([&](test::TestClient* client) {
     auto* data = client->set_data(std::make_unique<ClientData>());
     data->pointer.reset(wl_seat_get_pointer(client->seat()));
     pointer_id = ProxyId(data->pointer.get());
     pointer_resource_key =
         test::client_util::GetResourceKey(data->pointer.get());
   });

   // Act: Send a motion event
   wl_resource* pointer_resource =
       test::server_util::LookUpResource(server_.get(), pointer_resource_key);
   EXPECT_NE(pointer_resource, nullptr);

   wl_pointer_send_motion(pointer_resource, 123, wl_fixed_from_double(1234.5),
                          wl_fixed_from_double(0));

   // Assert: Motion event correctly logged
   EXPECT_THAT(
       messages_,
       ::testing::Contains(::testing::ElementsAre(
           base::StrCat({"Sent event: wl_pointer@", pointer_id, ".motion"}),
           "123", "1234.5", "0")));
 }

 TEST_F(WaylandProtocolLoggerTest, LogsArrays) {
   std::string xdg_toplevel_id;
   test::ResourceKey xdg_toplevel_resource_key;

   PostToClientAndWait([&](test::TestClient* client) {
     auto* data = client->set_data(std::make_unique<ClientData>());
     data->surface.reset(wl_compositor_create_surface(client->compositor()));
     data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
                                                         data->surface.get()));
     data->xdg_toplevel.reset(xdg_surface_get_toplevel(data->xdg_surface.get()));
     xdg_toplevel_id = ProxyId(data->xdg_toplevel.get());
     xdg_toplevel_resource_key =
         test::client_util::GetResourceKey(data->xdg_toplevel.get());
   });

   wl_resource* xdg_toplevel_resource = test::server_util::LookUpResource(
       server_.get(), xdg_toplevel_resource_key);
   EXPECT_NE(xdg_toplevel_resource, nullptr);

   // Act: Send a typical configure event.
   {
     messages_.clear();
     wl_array states;
     wl_array_init(&states);
     AddState(&states, XDG_TOPLEVEL_STATE_ACTIVATED);
     AddState(&states, XDG_TOPLEVEL_STATE_FULLSCREEN);
     xdg_toplevel_send_configure(xdg_toplevel_resource, 1024, 768, &states);
     wl_array_release(&states);
   }

   // Assert: Short arrays print correctly.
   EXPECT_THAT(messages_,
               ::testing::Contains(::testing::ElementsAre(
                   base::StrCat({"Sent event: xdg_toplevel@", xdg_toplevel_id,
                                 ".configure"}),
                   "1024", "768", "array[8 bytes]{0400000002000000}")));

   // Act: Send a very long array.
   {
     messages_.clear();
     wl_array states;
     wl_array_init(&states);
     for (int i = 0; i < 14; i++) {
       AddState(&states, XDG_TOPLEVEL_STATE_ACTIVATED);
     }
     xdg_toplevel_send_configure(xdg_toplevel_resource, 1024, 768, &states);
     wl_array_release(&states);
   }

   // Assert: Long arrays truncate as expected.
   EXPECT_THAT(messages_,
               ::testing::Contains(::testing::ElementsAre(
                   base::StrCat({"Sent event: xdg_toplevel@", xdg_toplevel_id,
                                 ".configure"}),
                   "1024", "768",
                   "array[56 bytes]"
                   "{04000000040000000400000004000000040000000400000004000000"
                   "0400000004000000040000000400000004000000...}")));
 }

 }  // namespace exo::wayland
	// Copyright 2024 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "components/exo/wayland/wayland_protocol_logger.h"

	#include <wayland-server-core.h>
	#include <wayland-util.h>
	#include <xdg-shell-client-protocol.h>
	#include <xdg-shell-server-protocol.h>

	#include "base/strings/strcat.h"
	#include "base/strings/string_number_conversions.h"
	#include "components/exo/wayland/test/client_util.h"
	#include "components/exo/wayland/test/resource_key.h"
	#include "components/exo/wayland/test/server_util.h"
	#include "components/exo/wayland/test/wayland_server_test.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace exo::wayland {
	namespace {

	class WaylandProtocolLoggerTest : public test::WaylandServerTest {
	public:
	WaylandProtocolLoggerTest() = default;
	WaylandProtocolLoggerTest(const WaylandProtocolLoggerTest&) = delete;
	WaylandProtocolLoggerTest& operator=(const WaylandProtocolLoggerTest&) =
	delete;
	~WaylandProtocolLoggerTest() override = default;

	// test::WaylandServerTest:
	void SetUp() override {
	WaylandProtocolLogger::SetHandlerFuncForTesting(
	[](void* user_data, wl_protocol_logger_type type,
	const wl_protocol_logger_message* message) {
	messages_.push_back(
	WaylandProtocolLogger::FormatMessage(type, message));
	});
	test::WaylandServerTest::SetUp();

	// Ignore messages from this test case's setup phase.
	messages_.clear();
	}

	// test::WaylandServerTest:
	void TearDown() override {
	messages_.clear();
	test::WaylandServerTest::TearDown();
	}

	static std::vector<std::vector<std::string>> messages_;
	};

	std::vector<std::vector<std::string>> WaylandProtocolLoggerTest::messages_ = {};

	class ClientData : public test::TestClient::CustomData {
	public:
	ClientData()
	: callback(nullptr, &wl_callback_destroy),
	data_source(nullptr, &wl_data_source_destroy),
	pointer(nullptr, &wl_pointer_destroy),
	surface(nullptr, &wl_surface_destroy),
	xdg_surface(nullptr, &xdg_surface_destroy),
	xdg_toplevel(nullptr, &xdg_toplevel_destroy) {}
	~ClientData() override = default;

	std::unique_ptr<wl_callback, decltype(&wl_callback_destroy)> callback;
	std::unique_ptr<wl_data_source, decltype(&wl_data_source_destroy)>
	data_source;
	std::unique_ptr<wl_pointer, decltype(&wl_pointer_destroy)> pointer;
	std::unique_ptr<wl_surface, decltype(&wl_surface_destroy)> surface;
	std::unique_ptr<xdg_surface, decltype(&xdg_surface_destroy)> xdg_surface;
	std::unique_ptr<xdg_toplevel, decltype(&xdg_toplevel_destroy)> xdg_toplevel;
	};

	std::string ProxyId(void* proxy) {
	return base::NumberToString(
	wl_proxy_get_id(reinterpret_cast<wl_proxy*>(proxy)));
	}

	void AddState(wl_array* states, xdg_toplevel_state state) {
	xdg_toplevel_state* value = static_cast<xdg_toplevel_state*>(
	wl_array_add(states, sizeof(xdg_toplevel_state)));
	DCHECK(value);
	*value = state;
	}

	} // namespace

	TEST_F(WaylandProtocolLoggerTest, LogsBasicRequest) {
	std::string surface_id;
	std::string compositor_id;

	PostToClientAndWait([&](test::TestClient* client) {
	auto* data = client->set_data(std::make_unique<ClientData>());
	data->surface.reset(wl_compositor_create_surface(client->compositor()));
	compositor_id = ProxyId(client->compositor());
	surface_id = ProxyId(data->surface.get());
	});

	EXPECT_THAT(messages_,
	::testing::Contains(::testing::ElementsAre(
	base::StrCat({"Received request: wl_compositor@",
	compositor_id, ".create_surface"}),
	base::StrCat({"new id wl_surface@", surface_id}))));
	}

	TEST_F(WaylandProtocolLoggerTest, LogsBasicEvent) {
	std::string callback_id;

	EXPECT_THAT(messages_, ::testing::IsEmpty());

	PostToClientAndWait([&](test::TestClient* client) {
	auto* data = client->set_data(std::make_unique<ClientData>());
	data->callback.reset(wl_display_sync(client->display()));
	callback_id = ProxyId(data->callback.get());
	});

	EXPECT_THAT(messages_,
	::testing::Contains(::testing::Contains(base::StrCat(
	{"Sent event: wl_callback@", callback_id, ".done"}))));
	}

	TEST_F(WaylandProtocolLoggerTest, LogsObjects) {
	std::string xdg_wm_base_id;
	std::string xdg_surface_id;
	std::string surface_id;

	PostToClientAndWait([&](test::TestClient* client) {
	auto* data = client->set_data(std::make_unique<ClientData>());
	xdg_wm_base_id = ProxyId(client->xdg_wm_base());
	data->surface.reset(wl_compositor_create_surface(client->compositor()));
	data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
	data->surface.get()));
	surface_id = ProxyId(data->surface.get());
	xdg_surface_id = ProxyId(data->xdg_surface.get());
	});

	EXPECT_THAT(messages_,
	::testing::Contains(::testing::ElementsAre(
	base::StrCat({"Received request: xdg_wm_base@",
	xdg_wm_base_id, ".get_xdg_surface"}),
	base::StrCat({"new id xdg_surface@", xdg_surface_id}),
	base::StrCat({"wl_surface@", surface_id}))));
	}

	TEST_F(WaylandProtocolLoggerTest, LogsStrings) {
	constexpr const char* window_title = "🦄🌈 I ♥️ UTF-8 😋";
	std::string xdg_toplevel_id;

	PostToClientAndWait([&](test::TestClient* client) {
	auto* data = client->set_data(std::make_unique<ClientData>());
	data->surface.reset(wl_compositor_create_surface(client->compositor()));
	data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
	data->surface.get()));
	data->xdg_toplevel.reset(xdg_surface_get_toplevel(data->xdg_surface.get()));
	xdg_toplevel_set_title(data->xdg_toplevel.get(), window_title);
	xdg_toplevel_id = ProxyId(data->xdg_toplevel.get());
	});

	EXPECT_THAT(messages_, ::testing::Contains(::testing::ElementsAre(
	base::StrCat({"Received request: xdg_toplevel@",
	xdg_toplevel_id, ".set_title"}),
	window_title)));
	}

	// TODO(b/335767378): triggers dangling pointer detection.
	TEST_F(WaylandProtocolLoggerTest, DISABLED_LogsObjectsAndStrings) {
	std::string display_id;
	constexpr uint32_t fake_error_code = 0x12345678u;
	constexpr const char* fake_error = "🦄🌈 Fake error 😋";
	EXPECT_THAT(messages_, ::testing::IsEmpty());

	PostToClientAndWait([&](test::TestClient* client) {
	wl_resource_post_error(test::server_util::LookUpResource(
	server_.get(), test::client_util::GetResourceKey(
	client->display())),
	fake_error_code, "%s", fake_error);
	display_id = ProxyId(client->display());
	});

	EXPECT_THAT(
	messages_,
	::testing::Contains(::testing::ElementsAre(
	base::StrCat({"Sent event: wl_display@", display_id, ".error"}),
	base::StrCat({"wl_display@", display_id}),
	base::NumberToString(fake_error_code), fake_error)));
	}

	TEST_F(WaylandProtocolLoggerTest, LogsFileDescriptors) {
	std::string data_source_id;
	test::ResourceKey data_source_resource_key;

	PostToClientAndWait([&](test::TestClient* client) {
	auto* data = client->set_data(std::make_unique<ClientData>());
	data->data_source.reset(wl_data_device_manager_create_data_source(
	client->data_device_manager()));
	data_source_id = ProxyId(data->data_source.get());
	data_source_resource_key =
	test::client_util::GetResourceKey(data->data_source.get());
	});

	wl_resource* data_source_resource = test::server_util::LookUpResource(
	server_.get(), data_source_resource_key);
	EXPECT_NE(data_source_resource, nullptr);

	// Actually sending a wl_data_source::send event requires a valid file
	// descriptor, which requires some ceremony to set up properly.
	// Instead, call the message formatting utility directly.
	const struct wl_interface* arg_types[2] = {nullptr, nullptr};
	wl_message message = {
	.name = "send", .signature = "sh", .types = &arg_types[0]};
	wl_argument args[] = {{.s = "text/plain"}, {.h = 12345}};
	wl_protocol_logger_message logger_message = {
	.resource = data_source_resource,
	.message_opcode = WL_DATA_SOURCE_SEND,
	.message = &message,
	.arguments_count = 2,
	.arguments = &args[0],
	};

	auto result = WaylandProtocolLogger::FormatMessage(WL_PROTOCOL_LOGGER_EVENT,
	&logger_message);
	EXPECT_THAT(result, ::testing::ElementsAre(
	base::StrCat({"Sent event: wl_data_source@",
	data_source_id, ".send"}),
	"text/plain", "fd 12345"));
	}

	TEST_F(WaylandProtocolLoggerTest, LogsFixedPointNumbers) {
	// Arrange: Create a wl_pointer client object, wait for server to receive.
	std::string pointer_id;
	test::ResourceKey pointer_resource_key;

	PostToClientAndWait([&](test::TestClient* client) {
	auto* data = client->set_data(std::make_unique<ClientData>());
	data->pointer.reset(wl_seat_get_pointer(client->seat()));
	pointer_id = ProxyId(data->pointer.get());
	pointer_resource_key =
	test::client_util::GetResourceKey(data->pointer.get());
	});

	// Act: Send a motion event
	wl_resource* pointer_resource =
	test::server_util::LookUpResource(server_.get(), pointer_resource_key);
	EXPECT_NE(pointer_resource, nullptr);

	wl_pointer_send_motion(pointer_resource, 123, wl_fixed_from_double(1234.5),
	wl_fixed_from_double(0));

	// Assert: Motion event correctly logged
	EXPECT_THAT(
	messages_,
	::testing::Contains(::testing::ElementsAre(
	base::StrCat({"Sent event: wl_pointer@", pointer_id, ".motion"}),
	"123", "1234.5", "0")));
	}

	TEST_F(WaylandProtocolLoggerTest, LogsArrays) {
	std::string xdg_toplevel_id;
	test::ResourceKey xdg_toplevel_resource_key;

	PostToClientAndWait([&](test::TestClient* client) {
	auto* data = client->set_data(std::make_unique<ClientData>());
	data->surface.reset(wl_compositor_create_surface(client->compositor()));
	data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
	data->surface.get()));
	data->xdg_toplevel.reset(xdg_surface_get_toplevel(data->xdg_surface.get()));
	xdg_toplevel_id = ProxyId(data->xdg_toplevel.get());
	xdg_toplevel_resource_key =
	test::client_util::GetResourceKey(data->xdg_toplevel.get());
	});

	wl_resource* xdg_toplevel_resource = test::server_util::LookUpResource(
	server_.get(), xdg_toplevel_resource_key);
	EXPECT_NE(xdg_toplevel_resource, nullptr);

	// Act: Send a typical configure event.
	{
	messages_.clear();
	wl_array states;
	wl_array_init(&states);
	AddState(&states, XDG_TOPLEVEL_STATE_ACTIVATED);
	AddState(&states, XDG_TOPLEVEL_STATE_FULLSCREEN);
	xdg_toplevel_send_configure(xdg_toplevel_resource, 1024, 768, &states);
	wl_array_release(&states);
	}

	// Assert: Short arrays print correctly.
	EXPECT_THAT(messages_,
	::testing::Contains(::testing::ElementsAre(
	base::StrCat({"Sent event: xdg_toplevel@", xdg_toplevel_id,
	".configure"}),
	"1024", "768", "array[8 bytes]{0400000002000000}")));

	// Act: Send a very long array.
	{
	messages_.clear();
	wl_array states;
	wl_array_init(&states);
	for (int i = 0; i < 14; i++) {
	AddState(&states, XDG_TOPLEVEL_STATE_ACTIVATED);
	}
	xdg_toplevel_send_configure(xdg_toplevel_resource, 1024, 768, &states);
	wl_array_release(&states);
	}

	// Assert: Long arrays truncate as expected.
	EXPECT_THAT(messages_,
	::testing::Contains(::testing::ElementsAre(
	base::StrCat({"Sent event: xdg_toplevel@", xdg_toplevel_id,
	".configure"}),
	"1024", "768",
	"array[56 bytes]"
	"{04000000040000000400000004000000040000000400000004000000"
	"0400000004000000040000000400000004000000...}")));
	}

	} // namespace exo::wayland