tests/wp_viewporter.cpp - external/github.com/MirServer/wlcs - Git at Google

 /*
  * Copyright © Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
  * as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */

 #include "in_process_server.h"
 #include "expect_protocol_error.h"
 #include "version_specifier.h"
 #include "wayland-util.h"

 #include "generated/viewporter-client.h"

 #include <memory>
 #include <utility>

 #include <gtest/gtest.h>
 #include <gmock/gmock.h>

 using namespace testing;
 using namespace wlcs;

 namespace wlcs
 {
 WLCS_CREATE_INTERFACE_DESCRIPTOR(wp_viewporter)
 WLCS_CREATE_INTERFACE_DESCRIPTOR(wp_viewport)
 }


 class WpViewporterTest : public wlcs::InProcessServer
 {
 public:
     WpViewporterTest() = default;

     auto surface_has_size(wlcs::Client& client, wlcs::Surface& surface, int32_t width, int32_t height) -> bool
     {
         the_server().move_surface_to(surface, 100, 100);

         auto pointer = the_server().create_pointer();

         // Use a shared ptr to extend the lifetime of the variables until the
         // pointer/motion notifications are done with them. Otherwise, we get a
         // use-after-free.
         auto const pointer_entered = std::make_shared<bool>(false);
         auto const motion_received = std::make_shared<bool>(false);
         client.add_pointer_enter_notification(
             [&surface, pointer_entered](auto entered_surface, auto, auto)
             {
                 *pointer_entered = (entered_surface == surface);
                 return false;
             });

         // First ensure we are *not* on the surface...
         pointer.move_to(0, 0);
         // ...then move onto the surface, so our enter notification fires
         pointer.move_to(100, 100);
         client.dispatch_until([pointer_entered]() { return *pointer_entered; });

         // Should be on the top left of the surface
         if (client.window_under_cursor() != surface)
         {
             ADD_FAILURE() << "Surface is not mapped at expected location?";
             return false;
         }
         if (client.pointer_position() != std::make_pair(wl_fixed_from_int(0), wl_fixed_from_int(0)))
         {
             BOOST_THROW_EXCEPTION((std::runtime_error{"Surface at unexpected location (test harness bug?)"}));
         }

         client.add_pointer_motion_notification(
             [motion_received](auto, auto)
             {
                 *motion_received = true;
                 return false;
             });
         client.add_pointer_leave_notification(
             [pointer_entered](auto)
             {
                 *pointer_entered = false;
                 return false;
             });

         pointer.move_by(width - 1, height - 1);
         client.dispatch_until([&]() { return *motion_received || !*pointer_entered; });

         // Should now be at bottom corner of surface
         if (client.window_under_cursor() != surface)
         {
             ADD_FAILURE() << "Surface size too small";
             return false;
         }
         if (client.pointer_position() != std::make_pair(wl_fixed_from_int(width - 1), wl_fixed_from_int(height - 1)))
         {
             auto const [x, y] = client.pointer_position();
             ADD_FAILURE() << "Surface coordinate system incorrect; expected (" << width - 1 << ", " << height - 1 << ") got ("
                 << wl_fixed_to_double(x) << ", " << wl_fixed_to_double(y) << ")";
             return false;
         }

         // Moving any further should take us out of the surface
         *motion_received = false;

         client.add_pointer_leave_notification(
             [pointer_entered](auto)
             {
                 *pointer_entered = false;
                 return false;
             });

         client.add_pointer_motion_notification(
             [motion_received](auto, auto)
             {
                 *motion_received = true;
                 return false;
             });

         pointer.move_by(1, 1);
         client.dispatch_until([&]() { return !*pointer_entered || *motion_received; });

         if (client.window_under_cursor() == surface)
         {
             ADD_FAILURE() << "Surface size too large";
             return false;
         }

         return true;
     }
 };

 TEST_F(WpViewporterTest, set_destination_sets_output_size)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{100}, buffer_height{100}, display_width{83}, display_height{20};

     auto surface = client.create_visible_surface(buffer_width, buffer_height);
     auto buffer = ShmBuffer(client, buffer_width, buffer_height);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     wp_viewport_set_destination(viewport, display_width, display_height);
     wl_surface_attach(surface, buffer, 0, 0);
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
 }

 TEST_F(WpViewporterTest, committing_new_destination_without_new_buffer_still_changes_size)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{100}, buffer_height{100}, display_width{83}, display_height{20};

     auto surface = client.create_visible_surface(buffer_width, buffer_height);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     wp_viewport_set_destination(viewport, display_width, display_height);
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
 }

 TEST_F(WpViewporterTest, when_source_but_no_destination_set_window_has_src_size)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{100}, buffer_height{100}, display_width{83}, display_height{20};

     auto surface = client.create_visible_surface(buffer_width, buffer_height);
     auto buffer = ShmBuffer(client, buffer_width, buffer_height);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     wp_viewport_set_source(viewport, 0, 0, wl_fixed_from_int(display_width), wl_fixed_from_int(display_height));
     // Oh! I think we handle changing surface properties incorrectly!
     wl_surface_attach(surface, buffer, 0, 0);
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
 }

 TEST_F(WpViewporterTest, when_buffer_is_scaled_destination_is_in_scaled_coordinates)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{100}, buffer_height{100}, display_width{82}, display_height{20};
     int const scale{2};

     auto surface = client.create_visible_surface(buffer_width, buffer_height);
     auto buffer = ShmBuffer(client, buffer_width, buffer_height);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     wl_surface_set_buffer_scale(surface, scale);
     wp_viewport_set_destination(viewport, display_width, display_height);
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
 }

 TEST_F(WpViewporterTest, when_buffer_is_scaled_source_is_in_scaled_coordinates)
 {
     /* TODO: It would be nice to check that the surface is *actually* sampling from
      * the appropriate source rectangle, rather than relying on the indirect “does it
      * end up the right size” method here.
      *
      * That would require sampling-from-rendering support in WLCS and associated
      * compositors-under-test.
      */

     wlcs::Client client{the_server()};

     int const buffer_width{200}, buffer_height{100}, display_width{82}, display_height{20};
     int const scale{2};

     auto surface = client.create_visible_surface(buffer_width, buffer_height);
     auto buffer = ShmBuffer(client, buffer_width, buffer_height);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     wl_surface_set_buffer_scale(surface, scale);
     wp_viewport_set_source(viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_int(display_width), wl_fixed_from_int(display_height));
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
 }

 TEST_F(WpViewporterTest, when_destination_is_not_set_source_must_have_integer_size)
 {
     wlcs::Client client{the_server()};

     auto surface = client.create_visible_surface(200, 100);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     wp_viewport_set_source(viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_double(23.2f), wl_fixed_from_int(100));
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     EXPECT_PROTOCOL_ERROR(
         {
             client.dispatch_until([&committed]() { return committed;} );
         },
         &wp_viewport_interface,
         WP_VIEWPORT_ERROR_BAD_SIZE
     );
 }

 TEST_F(WpViewporterTest, source_rectangle_out_of_buffer_bounds_raises_protocol_error)
 {
     wlcs::Client client{the_server()};

     auto surface = client.create_visible_surface(200, 100);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     // Set the surface scale to test that interaction with surface coördinates
     wl_surface_set_buffer_scale(surface, 2);
     // Set a source viewport outside the (transformed) buffer coordinates - this corresponds to the rectangle with corners (100, 0) -> (201, 100)
     wp_viewport_set_source(viewport, wl_fixed_from_int(50), wl_fixed_from_int(0), wl_fixed_from_double(50.5), wl_fixed_from_int(50));
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     EXPECT_PROTOCOL_ERROR(
         {
             client.dispatch_until([&committed]() { return committed;} );
         },
         &wp_viewport_interface,
         WP_VIEWPORT_ERROR_OUT_OF_BUFFER
     );
 }

 TEST_F(WpViewporterTest, assigning_a_viewport_to_a_surface_with_an_existing_viewport_is_an_error)
 {
     wlcs::Client client{the_server()};

     auto surface = client.create_visible_surface(200, 100);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     wp_viewporter_get_viewport(viewporter, surface);

     EXPECT_PROTOCOL_ERROR(
         {
             wp_viewporter_get_viewport(viewporter, surface);
             client.roundtrip();
         },
         &wp_viewporter_interface,
         WP_VIEWPORTER_ERROR_VIEWPORT_EXISTS
     );
 }

 TEST_F(WpViewporterTest, setting_destination_after_surface_has_been_destroyed_is_an_error)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{100}, buffer_height{100};

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     struct wp_viewport* viewport = nullptr;

     {
         auto surface = client.create_visible_surface(buffer_width, buffer_height);
         viewport = wp_viewporter_get_viewport(viewporter, surface);
     }

     EXPECT_PROTOCOL_ERROR(
         {
             wp_viewport_set_destination(viewport, 10, 10);
             client.roundtrip();
         },
         &wp_viewport_interface,
         WP_VIEWPORT_ERROR_NO_SURFACE
     );
 }

 TEST_F(WpViewporterTest, setting_source_after_surface_has_been_destroyed_is_an_error)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{100}, buffer_height{100};

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     struct wp_viewport* viewport = nullptr;

     {
         auto surface = client.create_visible_surface(buffer_width, buffer_height);
         viewport = wp_viewporter_get_viewport(viewporter, surface);
     }

     EXPECT_PROTOCOL_ERROR(
         {
             wp_viewport_set_source(viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_int(10), wl_fixed_from_int(10));
             client.roundtrip();
         },
         &wp_viewport_interface,
         WP_VIEWPORT_ERROR_NO_SURFACE
     );
 }

 TEST_F(WpViewporterTest, can_destroy_viewport_after_surface_is_destroyed)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{100}, buffer_height{100};

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     struct wp_viewport* viewport = nullptr;

     {
         auto surface = client.create_visible_surface(buffer_width, buffer_height);
         viewport = wp_viewporter_get_viewport(viewporter, surface);
         client.roundtrip();
     }

     wp_viewport_destroy(viewport);
     client.roundtrip();
 }

 class WpViewporterSrcParamsTest : public WpViewporterTest, public testing::WithParamInterface<std::tuple<double, double, double, double, char const*>>
 {
 };

 TEST_P(WpViewporterSrcParamsTest, raises_protocol_error_on_invalid_value)
 {
     wlcs::Client client{the_server()};

     auto surface = client.create_visible_surface(200, 100);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     auto const [x, y, width, height, _] = GetParam();

     EXPECT_PROTOCOL_ERROR(
         {
             wp_viewport_set_source(viewport, wl_fixed_from_double(x), wl_fixed_from_double(y), wl_fixed_from_double(width), wl_fixed_from_double(height));
             client.roundtrip();
         },
         &wp_viewport_interface,
         WP_VIEWPORT_ERROR_BAD_VALUE
     );
 }

 INSTANTIATE_TEST_SUITE_P(
     ,
     WpViewporterSrcParamsTest,
     Values(
         std::make_tuple(0, 0, -1, 0, "src_width_must_be_non_negative"),
         std::make_tuple(0, 0, 0, -1, "src_height_must_be_non_negative"),
         std::make_tuple(0, 0, 1, 0, "src_height_must_be_positive"),
         std::make_tuple(0, 0, 0, 1, "src_width_must_be_positive"),
         std::make_tuple(-1, 0, 0, 0, "src_x_must_be_non_negative"),
         std::make_tuple(0, -1, 0, 0, "src_y_must_be_non_negative")
     ),
     [](testing::TestParamInfo<WpViewporterSrcParamsTest::ParamType> const& info) -> std::string
     {
         return std::get<4>(info.param);
     });

 TEST_F(WpViewporterTest, all_minus_one_source_unsets_source_rect)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{640}, buffer_height{480}, display_width{320}, display_height{200};

     auto surface = client.create_visible_surface(buffer_width, buffer_height);
     auto buffer = ShmBuffer(client, buffer_width, buffer_height);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     // First set the source viewport, and assert that we get the right surface size...
     wp_viewport_set_source(viewport, 0, 0, wl_fixed_from_int(display_width), wl_fixed_from_int(display_height));
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     ASSERT_TRUE(surface_has_size(client, surface, display_width, display_height));

     // Now, set the source viewport to all -1, and expect that we go back to un-viewported size
     committed = false;
     wp_viewport_set_source(viewport, wl_fixed_from_int(-1), wl_fixed_from_int(-1), wl_fixed_from_int(-1), wl_fixed_from_int(-1));
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     EXPECT_TRUE(surface_has_size(client, surface, buffer_width, buffer_height));
 }

 class WpViewporterDestParamsTest : public WpViewporterTest, public testing::WithParamInterface<std::tuple<int32_t, int32_t, char const*>>
 {
 };

 TEST_P(WpViewporterDestParamsTest, raises_protocol_error_on_invalid_value)
 {
     wlcs::Client client{the_server()};

     auto surface = client.create_visible_surface(200, 100);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     auto const [width, height, _] = GetParam();

     EXPECT_PROTOCOL_ERROR(
         {
             wp_viewport_set_destination(viewport, width, height);
             client.roundtrip();
         },
         &wp_viewport_interface,
         WP_VIEWPORT_ERROR_BAD_VALUE
     );
 }

 INSTANTIATE_TEST_SUITE_P(
     ,
     WpViewporterDestParamsTest,
     Values(
         std::make_tuple(-1, 0, "width_must_be_non_negative"),
         std::make_tuple(0, -1, "height_must_be_non_negative"),
         std::make_tuple(1, 0, "height_must_be_positive"),
         std::make_tuple(0, 1, "width_must_be_positive")
     ),
     [](testing::TestParamInfo<WpViewporterDestParamsTest::ParamType> const& info) -> std::string
     {
         return std::get<2>(info.param);
     });

 TEST_F(WpViewporterTest, all_minus_one_destination_unsets_destination_viewport)
 {
     wlcs::Client client{the_server()};

     int const buffer_width{640}, buffer_height{480}, display_width{320}, display_height{200};

     auto surface = client.create_visible_surface(buffer_width, buffer_height);
     auto buffer = ShmBuffer(client, buffer_width, buffer_height);

     auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
     auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

     bool committed = false;

     // First set the destination viewport, and assert that we get the right surface size...
     wp_viewport_set_destination(viewport, display_width, display_height);
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     ASSERT_TRUE(surface_has_size(client, surface, display_width, display_height));

     // Now, set the source viewport to all -1, and expect that we go back to un-viewported size
     committed = false;
     wp_viewport_set_destination(viewport, -1, -1);
     surface.add_frame_callback([&committed](auto) { committed = true; });
     wl_surface_commit(surface);

     client.dispatch_until([&committed]() { return committed;} );

     EXPECT_TRUE(surface_has_size(client, surface, buffer_width, buffer_height));
 }
	/*
	* Copyright © Canonical Ltd.
	*
	* This program is free software: you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 3,
	* as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "in_process_server.h"
	#include "expect_protocol_error.h"
	#include "version_specifier.h"
	#include "wayland-util.h"

	#include "generated/viewporter-client.h"

	#include <memory>
	#include <utility>

	#include <gtest/gtest.h>
	#include <gmock/gmock.h>

	using namespace testing;
	using namespace wlcs;

	namespace wlcs
	{
	WLCS_CREATE_INTERFACE_DESCRIPTOR(wp_viewporter)
	WLCS_CREATE_INTERFACE_DESCRIPTOR(wp_viewport)
	}


	class WpViewporterTest : public wlcs::InProcessServer
	{
	public:
	WpViewporterTest() = default;

	auto surface_has_size(wlcs::Client& client, wlcs::Surface& surface, int32_t width, int32_t height) -> bool
	{
	the_server().move_surface_to(surface, 100, 100);

	auto pointer = the_server().create_pointer();

	// Use a shared ptr to extend the lifetime of the variables until the
	// pointer/motion notifications are done with them. Otherwise, we get a
	// use-after-free.
	auto const pointer_entered = std::make_shared<bool>(false);
	auto const motion_received = std::make_shared<bool>(false);
	client.add_pointer_enter_notification(
	[&surface, pointer_entered](auto entered_surface, auto, auto)
	{
	*pointer_entered = (entered_surface == surface);
	return false;
	});

	// First ensure we are not on the surface...
	pointer.move_to(0, 0);
	// ...then move onto the surface, so our enter notification fires
	pointer.move_to(100, 100);
	client.dispatch_until([pointer_entered]() { return *pointer_entered; });

	// Should be on the top left of the surface
	if (client.window_under_cursor() != surface)
	{
	ADD_FAILURE() << "Surface is not mapped at expected location?";
	return false;
	}
	if (client.pointer_position() != std::make_pair(wl_fixed_from_int(0), wl_fixed_from_int(0)))
	{
	BOOST_THROW_EXCEPTION((std::runtime_error{"Surface at unexpected location (test harness bug?)"}));
	}

	client.add_pointer_motion_notification(
	[motion_received](auto, auto)
	{
	*motion_received = true;
	return false;
	});
	client.add_pointer_leave_notification(
	[pointer_entered](auto)
	{
	*pointer_entered = false;
	return false;
	});

	pointer.move_by(width - 1, height - 1);
	client.dispatch_until([&]() { return motion_received \|\| !pointer_entered; });

	// Should now be at bottom corner of surface
	if (client.window_under_cursor() != surface)
	{
	ADD_FAILURE() << "Surface size too small";
	return false;
	}
	if (client.pointer_position() != std::make_pair(wl_fixed_from_int(width - 1), wl_fixed_from_int(height - 1)))
	{
	auto const [x, y] = client.pointer_position();
	ADD_FAILURE() << "Surface coordinate system incorrect; expected (" << width - 1 << ", " << height - 1 << ") got ("
	<< wl_fixed_to_double(x) << ", " << wl_fixed_to_double(y) << ")";
	return false;
	}

	// Moving any further should take us out of the surface
	*motion_received = false;

	client.add_pointer_leave_notification(
	[pointer_entered](auto)
	{
	*pointer_entered = false;
	return false;
	});

	client.add_pointer_motion_notification(
	[motion_received](auto, auto)
	{
	*motion_received = true;
	return false;
	});

	pointer.move_by(1, 1);
	client.dispatch_until([&]() { return !pointer_entered \|\| motion_received; });

	if (client.window_under_cursor() == surface)
	{
	ADD_FAILURE() << "Surface size too large";
	return false;
	}

	return true;
	}
	};

	TEST_F(WpViewporterTest, set_destination_sets_output_size)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{100}, buffer_height{100}, display_width{83}, display_height{20};

	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	auto buffer = ShmBuffer(client, buffer_width, buffer_height);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	wp_viewport_set_destination(viewport, display_width, display_height);
	wl_surface_attach(surface, buffer, 0, 0);
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
	}

	TEST_F(WpViewporterTest, committing_new_destination_without_new_buffer_still_changes_size)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{100}, buffer_height{100}, display_width{83}, display_height{20};

	auto surface = client.create_visible_surface(buffer_width, buffer_height);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	wp_viewport_set_destination(viewport, display_width, display_height);
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
	}

	TEST_F(WpViewporterTest, when_source_but_no_destination_set_window_has_src_size)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{100}, buffer_height{100}, display_width{83}, display_height{20};

	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	auto buffer = ShmBuffer(client, buffer_width, buffer_height);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	wp_viewport_set_source(viewport, 0, 0, wl_fixed_from_int(display_width), wl_fixed_from_int(display_height));
	// Oh! I think we handle changing surface properties incorrectly!
	wl_surface_attach(surface, buffer, 0, 0);
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
	}

	TEST_F(WpViewporterTest, when_buffer_is_scaled_destination_is_in_scaled_coordinates)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{100}, buffer_height{100}, display_width{82}, display_height{20};
	int const scale{2};

	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	auto buffer = ShmBuffer(client, buffer_width, buffer_height);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	wl_surface_set_buffer_scale(surface, scale);
	wp_viewport_set_destination(viewport, display_width, display_height);
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
	}

	TEST_F(WpViewporterTest, when_buffer_is_scaled_source_is_in_scaled_coordinates)
	{
	/* TODO: It would be nice to check that the surface is actually sampling from
	* the appropriate source rectangle, rather than relying on the indirect “does it
	* end up the right size” method here.
	*
	* That would require sampling-from-rendering support in WLCS and associated
	* compositors-under-test.
	*/

	wlcs::Client client{the_server()};

	int const buffer_width{200}, buffer_height{100}, display_width{82}, display_height{20};
	int const scale{2};

	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	auto buffer = ShmBuffer(client, buffer_width, buffer_height);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	wl_surface_set_buffer_scale(surface, scale);
	wp_viewport_set_source(viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_int(display_width), wl_fixed_from_int(display_height));
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	EXPECT_TRUE(surface_has_size(client, surface, display_width, display_height));
	}

	TEST_F(WpViewporterTest, when_destination_is_not_set_source_must_have_integer_size)
	{
	wlcs::Client client{the_server()};

	auto surface = client.create_visible_surface(200, 100);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	wp_viewport_set_source(viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_double(23.2f), wl_fixed_from_int(100));
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	EXPECT_PROTOCOL_ERROR(
	{
	client.dispatch_until([&committed]() { return committed;} );
	},
	&wp_viewport_interface,
	WP_VIEWPORT_ERROR_BAD_SIZE
	);
	}

	TEST_F(WpViewporterTest, source_rectangle_out_of_buffer_bounds_raises_protocol_error)
	{
	wlcs::Client client{the_server()};

	auto surface = client.create_visible_surface(200, 100);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	// Set the surface scale to test that interaction with surface coördinates
	wl_surface_set_buffer_scale(surface, 2);
	// Set a source viewport outside the (transformed) buffer coordinates - this corresponds to the rectangle with corners (100, 0) -> (201, 100)
	wp_viewport_set_source(viewport, wl_fixed_from_int(50), wl_fixed_from_int(0), wl_fixed_from_double(50.5), wl_fixed_from_int(50));
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	EXPECT_PROTOCOL_ERROR(
	{
	client.dispatch_until([&committed]() { return committed;} );
	},
	&wp_viewport_interface,
	WP_VIEWPORT_ERROR_OUT_OF_BUFFER
	);
	}

	TEST_F(WpViewporterTest, assigning_a_viewport_to_a_surface_with_an_existing_viewport_is_an_error)
	{
	wlcs::Client client{the_server()};

	auto surface = client.create_visible_surface(200, 100);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	wp_viewporter_get_viewport(viewporter, surface);

	EXPECT_PROTOCOL_ERROR(
	{
	wp_viewporter_get_viewport(viewporter, surface);
	client.roundtrip();
	},
	&wp_viewporter_interface,
	WP_VIEWPORTER_ERROR_VIEWPORT_EXISTS
	);
	}

	TEST_F(WpViewporterTest, setting_destination_after_surface_has_been_destroyed_is_an_error)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{100}, buffer_height{100};

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	struct wp_viewport* viewport = nullptr;

	{
	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	viewport = wp_viewporter_get_viewport(viewporter, surface);
	}

	EXPECT_PROTOCOL_ERROR(
	{
	wp_viewport_set_destination(viewport, 10, 10);
	client.roundtrip();
	},
	&wp_viewport_interface,
	WP_VIEWPORT_ERROR_NO_SURFACE
	);
	}

	TEST_F(WpViewporterTest, setting_source_after_surface_has_been_destroyed_is_an_error)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{100}, buffer_height{100};

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	struct wp_viewport* viewport = nullptr;

	{
	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	viewport = wp_viewporter_get_viewport(viewporter, surface);
	}

	EXPECT_PROTOCOL_ERROR(
	{
	wp_viewport_set_source(viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_int(10), wl_fixed_from_int(10));
	client.roundtrip();
	},
	&wp_viewport_interface,
	WP_VIEWPORT_ERROR_NO_SURFACE
	);
	}

	TEST_F(WpViewporterTest, can_destroy_viewport_after_surface_is_destroyed)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{100}, buffer_height{100};

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	struct wp_viewport* viewport = nullptr;

	{
	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	viewport = wp_viewporter_get_viewport(viewporter, surface);
	client.roundtrip();
	}

	wp_viewport_destroy(viewport);
	client.roundtrip();
	}

	class WpViewporterSrcParamsTest : public WpViewporterTest, public testing::WithParamInterface<std::tuple<double, double, double, double, char const*>>
	{
	};

	TEST_P(WpViewporterSrcParamsTest, raises_protocol_error_on_invalid_value)
	{
	wlcs::Client client{the_server()};

	auto surface = client.create_visible_surface(200, 100);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	auto const [x, y, width, height, _] = GetParam();

	EXPECT_PROTOCOL_ERROR(
	{
	wp_viewport_set_source(viewport, wl_fixed_from_double(x), wl_fixed_from_double(y), wl_fixed_from_double(width), wl_fixed_from_double(height));
	client.roundtrip();
	},
	&wp_viewport_interface,
	WP_VIEWPORT_ERROR_BAD_VALUE
	);
	}

	INSTANTIATE_TEST_SUITE_P(
	,
	WpViewporterSrcParamsTest,
	Values(
	std::make_tuple(0, 0, -1, 0, "src_width_must_be_non_negative"),
	std::make_tuple(0, 0, 0, -1, "src_height_must_be_non_negative"),
	std::make_tuple(0, 0, 1, 0, "src_height_must_be_positive"),
	std::make_tuple(0, 0, 0, 1, "src_width_must_be_positive"),
	std::make_tuple(-1, 0, 0, 0, "src_x_must_be_non_negative"),
	std::make_tuple(0, -1, 0, 0, "src_y_must_be_non_negative")
	),
	[](testing::TestParamInfo<WpViewporterSrcParamsTest::ParamType> const& info) -> std::string
	{
	return std::get<4>(info.param);
	});

	TEST_F(WpViewporterTest, all_minus_one_source_unsets_source_rect)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{640}, buffer_height{480}, display_width{320}, display_height{200};

	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	auto buffer = ShmBuffer(client, buffer_width, buffer_height);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	// First set the source viewport, and assert that we get the right surface size...
	wp_viewport_set_source(viewport, 0, 0, wl_fixed_from_int(display_width), wl_fixed_from_int(display_height));
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	ASSERT_TRUE(surface_has_size(client, surface, display_width, display_height));

	// Now, set the source viewport to all -1, and expect that we go back to un-viewported size
	committed = false;
	wp_viewport_set_source(viewport, wl_fixed_from_int(-1), wl_fixed_from_int(-1), wl_fixed_from_int(-1), wl_fixed_from_int(-1));
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	EXPECT_TRUE(surface_has_size(client, surface, buffer_width, buffer_height));
	}

	class WpViewporterDestParamsTest : public WpViewporterTest, public testing::WithParamInterface<std::tuple<int32_t, int32_t, char const*>>
	{
	};

	TEST_P(WpViewporterDestParamsTest, raises_protocol_error_on_invalid_value)
	{
	wlcs::Client client{the_server()};

	auto surface = client.create_visible_surface(200, 100);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	auto const [width, height, _] = GetParam();

	EXPECT_PROTOCOL_ERROR(
	{
	wp_viewport_set_destination(viewport, width, height);
	client.roundtrip();
	},
	&wp_viewport_interface,
	WP_VIEWPORT_ERROR_BAD_VALUE
	);
	}

	INSTANTIATE_TEST_SUITE_P(
	,
	WpViewporterDestParamsTest,
	Values(
	std::make_tuple(-1, 0, "width_must_be_non_negative"),
	std::make_tuple(0, -1, "height_must_be_non_negative"),
	std::make_tuple(1, 0, "height_must_be_positive"),
	std::make_tuple(0, 1, "width_must_be_positive")
	),
	[](testing::TestParamInfo<WpViewporterDestParamsTest::ParamType> const& info) -> std::string
	{
	return std::get<2>(info.param);
	});

	TEST_F(WpViewporterTest, all_minus_one_destination_unsets_destination_viewport)
	{
	wlcs::Client client{the_server()};

	int const buffer_width{640}, buffer_height{480}, display_width{320}, display_height{200};

	auto surface = client.create_visible_surface(buffer_width, buffer_height);
	auto buffer = ShmBuffer(client, buffer_width, buffer_height);

	auto viewporter = client.bind_if_supported<wp_viewporter>(wlcs::AnyVersion);
	auto viewport = wrap_wl_object(wp_viewporter_get_viewport(viewporter, surface));

	bool committed = false;

	// First set the destination viewport, and assert that we get the right surface size...
	wp_viewport_set_destination(viewport, display_width, display_height);
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	ASSERT_TRUE(surface_has_size(client, surface, display_width, display_height));

	// Now, set the source viewport to all -1, and expect that we go back to un-viewported size
	committed = false;
	wp_viewport_set_destination(viewport, -1, -1);
	surface.add_frame_callback([&committed](auto) { committed = true; });
	wl_surface_commit(surface);

	client.dispatch_until([&committed]() { return committed;} );

	EXPECT_TRUE(surface_has_size(client, surface, buffer_width, buffer_height));
	}