Merge lp:~alan-griffiths/mir/surface-has-min-size into lp:mir

[Alan Griffiths]

client API, shell: support for surfaces setting minimum size (and some code towards maximum)

client API, shell: support for surfaces setting minimum size (and some code towards maximum)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2489
http://jenkins.qa.ubuntu.com/job/mir-ci/3519/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2051
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2050
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2001
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1516
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1516/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2001
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2001/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4934
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19612

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3519/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

LGTM.

Nits:

+ #define COPY_IF_SET(field)\

Couldn't this be used above in the same method?

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2491
http://jenkins.qa.ubuntu.com/job/mir-ci/3528/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2063
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2062
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2013
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1525
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1525/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2013
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2013/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4946
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19646

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/3528/rebuild

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

See bug 1421591. We will eventually need more than min/max dimensions for real apps.

[Kevin DuBois (kdub)]

lgtm. It be good to validate that the mininum is less than or equal to the maximum if they're both set.

review: Approve

[Alberto Aguirre (albaguirre)]

LGTM

review: Approve

=== modified file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	2015-04-13 15:38:56 +0000
+++ include/client/mir_toolkit/mir_surface.h	2015-04-15 11:10:33 +0000
@@ -239,6 +239,48 @@
 bool mir_surface_spec_set_height(MirSurfaceSpec* spec, unsigned height);
 
 /**
+ * Set the minimum width, in pixels
+ *
+ * \param [in] spec     Specification to mutate
+ * \param [in] width    Minimum width.
+ * \return              False if minimum width is invalid for a surface of this type
+ * \note    The requested dimensions are a hint only. The server is not guaranteed to create a
+ *          surface of any specific width or height.
+ */
+bool mir_surface_spec_set_min_width(MirSurfaceSpec* spec, unsigned min_width);
+
+/**
+ * Set the minimum height, in pixels
+ *
+ * \param [in] spec     Specification to mutate
+ * \param [in] height   Minimum height.
+ * \return              False if minimum height is invalid for a surface of this type
+ * \note    The requested dimensions are a hint only. The server is not guaranteed to create a
+ *          surface of any specific width or height.
+ */
+bool mir_surface_spec_set_min_height(MirSurfaceSpec* spec, unsigned min_height);
+/**
+ * Set the maximum width, in pixels
+ *
+ * \param [in] spec     Specification to mutate
+ * \param [in] width    Maximum width.
+ * \return              False if maximum width is invalid for a surface of this type
+ * \note    The requested dimensions are a hint only. The server is not guaranteed to create a
+ *          surface of any specific width or height.
+ */
+bool mir_surface_spec_set_max_width(MirSurfaceSpec* spec, unsigned max_width);
+
+/**
+ * Set the maximum height, in pixels
+ *
+ * \param [in] spec     Specification to mutate
+ * \param [in] height   Maximum height.
+ * \return              False if maximum height is invalid for a surface of this type
+ * \note    The requested dimensions are a hint only. The server is not guaranteed to create a
+ *          surface of any specific width or height.
+ */
+bool mir_surface_spec_set_max_height(MirSurfaceSpec* spec, unsigned max_height);
+/**
  * Set the requested pixel format.
  * \param [in] spec     Specification to mutate
  * \param [in] format   Requested pixel format

=== modified file 'include/common/mir/geometry/dimensions.h'
--- include/common/mir/geometry/dimensions.h	2015-03-31 02:35:42 +0000
+++ include/common/mir/geometry/dimensions.h	2015-04-15 11:10:33 +0000
@@ -126,6 +126,10 @@
 inline Y operator+(Y lhs, DeltaY rhs) { return Y(lhs.as_int() + rhs.as_int()); }
 inline X operator-(X lhs, DeltaX rhs) { return X(lhs.as_int() - rhs.as_int()); }
 inline Y operator-(Y lhs, DeltaY rhs) { return Y(lhs.as_int() - rhs.as_int()); }
+inline X& operator+=(X& lhs, DeltaX rhs) { return lhs = X(lhs.as_int() + rhs.as_int()); }
+inline Y& operator+=(Y& lhs, DeltaY rhs) { return lhs = Y(lhs.as_int() + rhs.as_int()); }
+inline X& operator-=(X& lhs, DeltaX rhs) { return lhs = X(lhs.as_int() - rhs.as_int()); }
+inline Y& operator-=(Y& lhs, DeltaY rhs) { return lhs = Y(lhs.as_int() - rhs.as_int()); }
 
 // Adding deltas to Width and Height is fine
 inline Width operator+(Width lhs, DeltaX rhs) { return Width(lhs.as_int() + rhs.as_int()); }
@@ -137,6 +141,10 @@
 inline DeltaX operator-(X lhs, X rhs) { return DeltaX(lhs.as_int() - rhs.as_int()); }
 inline DeltaY operator-(Y lhs, Y rhs) { return DeltaY(lhs.as_int() - rhs.as_int()); }
 
+//Subtracting Width and Height is fine
+inline DeltaX operator-(Width lhs, Width rhs) { return DeltaX(lhs.as_int() - rhs.as_int()); }
+inline DeltaY operator-(Height lhs, Height rhs) { return DeltaY(lhs.as_int() - rhs.as_int()); }
+
 // Multiplying by a scalar value is fine
 template<typename Scalar>
 inline Width operator*(Scalar scale, Width const& w) { return Width{scale*w.as_int()}; }

=== modified file 'include/common/mir/geometry/point.h'
--- include/common/mir/geometry/point.h	2015-03-31 02:35:42 +0000
+++ include/common/mir/geometry/point.h	2015-04-15 11:10:33 +0000
@@ -56,6 +56,12 @@
 inline Point operator-(Point lhs, DeltaX rhs) { return{lhs.x - rhs, lhs.y}; }
 inline Point operator-(Point lhs, DeltaY rhs) { return{lhs.x, lhs.y - rhs}; }
 
+inline Point& operator+=(Point& lhs, DeltaX rhs) { lhs.x += rhs; return lhs; }
+inline Point& operator+=(Point& lhs, DeltaY rhs) { lhs.y += rhs; return lhs; }
+
+inline Point& operator-=(Point& lhs, DeltaX rhs) { lhs.x -= rhs; return lhs; }
+inline Point& operator-=(Point& lhs, DeltaY rhs) { lhs.y -= rhs; return lhs; }
+
 std::ostream& operator<<(std::ostream& out, Point const& value);
 }
 }

=== modified file 'include/server/mir/scene/surface_creation_parameters.h'
--- include/server/mir/scene/surface_creation_parameters.h	2015-01-23 03:50:26 +0000
+++ include/server/mir/scene/surface_creation_parameters.h	2015-04-15 11:10:33 +0000
@@ -89,6 +89,11 @@
     mir::optional_value<MirEdgeAttachment> edge_attachment;
 
     std::weak_ptr<Surface> parent;
+
+    optional_value<geometry::Width> min_width;
+    optional_value<geometry::Height> min_height;
+    optional_value<geometry::Width> max_width;
+    optional_value<geometry::Height> max_height;
 };
 
 bool operator==(const SurfaceCreationParameters& lhs, const SurfaceCreationParameters& rhs);

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2015-04-13 15:39:25 +0000
+++ src/client/mir_surface.cpp	2015-04-15 11:10:33 +0000
@@ -92,6 +92,10 @@
     SERIALIZE_OPTION_IF_SET(state, message);
     SERIALIZE_OPTION_IF_SET(pref_orientation, message);
     SERIALIZE_OPTION_IF_SET(edge_attachment, message);
+    SERIALIZE_OPTION_IF_SET(min_width, message);
+    SERIALIZE_OPTION_IF_SET(min_height, message);
+    SERIALIZE_OPTION_IF_SET(max_width, message);
+    SERIALIZE_OPTION_IF_SET(max_height, message);
 
     if (parent.is_set() && parent.value() != nullptr)
         message.set_parent_id(parent.value()->id());

=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2015-04-14 08:33:18 +0000
+++ src/client/mir_surface_api.cpp	2015-04-15 11:10:33 +0000
@@ -175,6 +175,30 @@
     return true;
 }
 
+bool mir_surface_spec_set_min_width(MirSurfaceSpec* spec, unsigned min_width)
+{
+    spec->min_width = min_width;
+    return true;
+}
+
+bool mir_surface_spec_set_min_height(MirSurfaceSpec* spec, unsigned min_height)
+{
+    spec->min_height = min_height;
+    return true;
+}
+
+bool mir_surface_spec_set_max_width(MirSurfaceSpec* spec, unsigned max_width)
+{
+    spec->max_width = max_width;
+    return true;
+}
+
+bool mir_surface_spec_set_max_height(MirSurfaceSpec* spec, unsigned max_height)
+{
+    spec->max_height = max_height;
+    return true;
+}
+
 bool mir_surface_spec_set_pixel_format(MirSurfaceSpec* spec, MirPixelFormat format)
 {
     spec->pixel_format = format;

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2015-04-09 16:15:52 +0000
+++ src/client/symbols.map	2015-04-15 11:10:33 +0000
@@ -164,6 +164,10 @@
     mir_surface_event_get_attribute;
     mir_surface_event_get_attribute_value;
     mir_surface_set_swapinterval;
+    mir_surface_spec_set_min_width;
+    mir_surface_spec_set_min_height;
+    mir_surface_spec_set_max_width;
+    mir_surface_spec_set_max_height;
     mir_surface_swap_buffers;
     mir_surface_swap_buffers_sync;
     mir_touch_event_modifiers;

=== modified file 'src/protobuf/mir_protobuf.proto'
--- src/protobuf/mir_protobuf.proto	2015-04-09 14:29:02 +0000
+++ src/protobuf/mir_protobuf.proto	2015-04-15 11:10:33 +0000
@@ -26,6 +26,11 @@
   
   optional Rectangle aux_rect = 11;
   optional int32 edge_attachment = 12;
+
+  optional int32 min_width = 13;
+  optional int32 min_height = 14;
+  optional int32 max_width = 15;
+  optional int32 max_height = 16;
 }
 
 // If and when we break our protocol backward-compatibility, this could be

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2015-04-09 14:29:02 +0000
+++ src/server/frontend/session_mediator.cpp	2015-04-15 11:10:33 +0000
@@ -231,6 +231,17 @@
     if (request->has_edge_attachment())
         params.with_edge_attachment(static_cast<MirEdgeAttachment>(request->edge_attachment()));
 
+    #define COPY_IF_SET(field)\
+        if (request->has_##field())\
+            params.field = decltype(params.field.value())(request->field())
+
+    COPY_IF_SET(min_width);
+    COPY_IF_SET(min_height);
+    COPY_IF_SET(max_width);
+    COPY_IF_SET(max_height);
+
+    #undef COPY_IF_SET
+
     auto const surf_id = shell->create_surface(session, params);
 
     auto surface = session->get_surface(surf_id);

=== modified file 'src/server/shell/basic_window_manager.h'
--- src/server/shell/basic_window_manager.h	2015-04-09 06:20:31 +0000
+++ src/server/shell/basic_window_manager.h	2015-04-15 11:10:33 +0000
@@ -98,7 +98,7 @@
 ///
 /// \tparam SessionInfo must be default constructable.
 ///
-/// \tparam SurfaceInfo must be constructable from (std::shared_ptr<ms::Session>, std::shared_ptr<ms::Surface>)
+/// \tparam SurfaceInfo must be constructable from (std::shared_ptr<ms::Session>, std::shared_ptr<ms::Surface>, ms::SurfaceCreationParameters const& params)
 template<typename WindowManagementPolicy, typename SessionInfo, typename SurfaceInfo>
 class BasicWindowManager : public WindowManager,
     private BasicWindowManagerTools<SessionInfo, SurfaceInfo>
@@ -138,7 +138,7 @@
         auto const result = build(session, placed_params);
         auto const surface = session->surface(result);
         policy.handle_new_surface(session, surface);
-        surface_info.emplace(surface, SurfaceInfo{session, surface});
+        surface_info.emplace(surface, SurfaceInfo{session, surface, placed_params});
         return result;
     }
 

=== modified file 'src/server/shell/canonical_window_manager.cpp'
--- src/server/shell/canonical_window_manager.cpp	2015-04-10 12:08:18 +0000
+++ src/server/shell/canonical_window_manager.cpp	2015-04-15 11:10:33 +0000
@@ -38,11 +38,16 @@
 
 msh::CanonicalSurfaceInfo::CanonicalSurfaceInfo(
     std::shared_ptr<scene::Session> const& session,
-    std::shared_ptr<scene::Surface> const& surface) :
+    std::shared_ptr<scene::Surface> const& surface,
+    scene::SurfaceCreationParameters const& params) :
     state{mir_surface_state_restored},
     restore_rect{surface->top_left(), surface->size()},
     session{session},
-    parent{surface->parent()}
+    parent{surface->parent()},
+    min_width{params.min_width},
+    min_height{params.min_height},
+    max_width{params.max_width},
+    max_height{params.max_height}
 {
 }
 
@@ -87,8 +92,16 @@
 
     auto width = std::min(display_area.size.width.as_int(), parameters.size.width.as_int());
     auto height = std::min(display_area.size.height.as_int(), parameters.size.height.as_int());
-    if (!width) width = 1;
-    if (!height) height = 1;
+
+    auto const min_width  = parameters.min_width.is_set() ?
+        parameters.min_width.value().as_int() : 1;
+
+    auto const min_height = parameters.min_height.is_set() ?
+        parameters.min_height.value().as_int() : 1;
+
+    width = std::max(width, min_width);
+    height = std::max(height, min_height);
+
     parameters.size = Size{width, height};
 
     bool positioned = false;
@@ -246,9 +259,23 @@
     std::shared_ptr<scene::Surface> const& surface,
     SurfaceSpecification const& modifications)
 {
+    auto& surface_info = tools->info_for(surface);
+
     if (modifications.name.is_set())
         surface->rename(modifications.name.value());
 
+    if (modifications.min_width.is_set())
+        surface_info.min_width = modifications.min_width;
+
+    if (modifications.min_height.is_set())
+        surface_info.min_height = modifications.min_height;
+
+    if (modifications.max_width.is_set())
+        surface_info.max_width = modifications.max_width;
+
+    if (modifications.max_height.is_set())
+        surface_info.max_height = modifications.max_height;
+
     if (modifications.width.is_set() || modifications.height.is_set())
     {
         // TODO similar logic is needed in example window management policies
@@ -566,7 +593,7 @@
 
 bool msh::CanonicalWindowManagerPolicy::resize(std::shared_ptr<ms::Surface> const& surface, Point cursor, Point old_cursor, Rectangle bounds)
 {
-    if (!surface || !surface->input_area_contains(cursor))
+    if (!surface || !surface->input_area_contains(old_cursor))
         return false;
 
     auto const top_left = surface->top_left();
@@ -608,6 +635,28 @@
     bool const top_resize,
     Rectangle const& bounds)
 {
+    auto const& surface_info = tools->info_for(surface);
+
+    if (surface_info.min_width.is_set() && surface_info.min_width.value() > new_size.width)
+    {
+        if (left_resize)
+        {
+            new_pos.x += surface_info.min_width.value() - new_size.width;
+        }
+
+        new_size.width = surface_info.min_width.value();
+    }
+
+    if (surface_info.min_height.is_set() && surface_info.min_height.value() > new_size.height)
+    {
+        if (top_resize)
+        {
+            new_pos.y += surface_info.min_height.value() - new_size.height;
+        }
+
+        new_size.height = surface_info.min_height.value();
+    }
+
     if (left_resize)
     {
         if (new_pos.x < bounds.top_left.x)
@@ -638,7 +687,7 @@
             new_size.height = new_size.height + to_bottom_right.dy;
     }
 
-    switch (tools->info_for(surface).state)
+    switch (surface_info.state)
     {
     case mir_surface_state_restored:
         break;

=== modified file 'src/server/shell/canonical_window_manager.h'
--- src/server/shell/canonical_window_manager.h	2015-04-10 12:08:18 +0000
+++ src/server/shell/canonical_window_manager.h	2015-04-15 11:10:33 +0000
@@ -38,13 +38,18 @@
 {
     CanonicalSurfaceInfo(
         std::shared_ptr<scene::Session> const& session,
-        std::shared_ptr<scene::Surface> const& surface);
+        std::shared_ptr<scene::Surface> const& surface,
+        scene::SurfaceCreationParameters const& params);
 
     MirSurfaceState state;
     geometry::Rectangle restore_rect;
     std::weak_ptr<scene::Session> session;
     std::weak_ptr<scene::Surface> parent;
     std::vector<std::weak_ptr<scene::Surface>> children;
+    optional_value<geometry::Width> min_width;
+    optional_value<geometry::Height> min_height;
+    optional_value<geometry::Width> max_width;
+    optional_value<geometry::Height> max_height;
 };
 
 // standard window management algorithm:

=== modified file 'tests/acceptance-tests/test_client_library.cpp'
--- tests/acceptance-tests/test_client_library.cpp	2015-04-09 06:20:31 +0000
+++ tests/acceptance-tests/test_client_library.cpp	2015-04-15 11:10:33 +0000
@@ -279,6 +279,111 @@
     mir_connection_release(connection);
 }
 
+TEST_F(ClientLibrary, can_set_surface_min_width)
+{
+    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    int const width = 640;
+    int const height = 480;
+    auto const format = mir_pixel_format_abgr_8888;
+    auto const spec =
+        mir_connection_create_spec_for_normal_surface(connection, width, height, format);
+
+    int const min_width = 480;
+    EXPECT_TRUE(mir_surface_spec_set_min_width(spec, min_width));
+
+    surface = mir_surface_create_sync(spec);
+    mir_surface_spec_release(spec);
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+TEST_F(ClientLibrary, can_set_surface_min_height)
+{
+    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    int const width = 640;
+    int const height = 480;
+    auto const format = mir_pixel_format_abgr_8888;
+    auto const spec =
+        mir_connection_create_spec_for_normal_surface(connection, width, height, format);
+
+    int const min_height = 480;
+    EXPECT_TRUE(mir_surface_spec_set_min_height(spec, min_height));
+
+    surface = mir_surface_create_sync(spec);
+    mir_surface_spec_release(spec);
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+TEST_F(ClientLibrary, can_set_surface_max_width)
+{
+    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    int const width = 640;
+    int const height = 480;
+    auto const format = mir_pixel_format_abgr_8888;
+    auto const spec =
+        mir_connection_create_spec_for_normal_surface(connection, width, height, format);
+
+    int const max_width = 1024;
+    EXPECT_TRUE(mir_surface_spec_set_max_width(spec, max_width));
+
+    surface = mir_surface_create_sync(spec);
+    mir_surface_spec_release(spec);
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+TEST_F(ClientLibrary, can_set_surface_max_height)
+{
+    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    int const width = 640;
+    int const height = 480;
+    auto const format = mir_pixel_format_abgr_8888;
+    auto const spec =
+        mir_connection_create_spec_for_normal_surface(connection, width, height, format);
+
+    int const max_height = 1024;
+    EXPECT_TRUE(mir_surface_spec_set_max_height(spec, max_height));
+
+    surface = mir_surface_create_sync(spec);
+    mir_surface_spec_release(spec);
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+TEST_F(ClientLibrary, min_size_respected_when_placing_surface)
+{
+    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    int const width = 6400;
+    int const height = 4800;
+    auto const format = mir_pixel_format_abgr_8888;
+    auto const spec =
+        mir_connection_create_spec_for_normal_surface(connection, width, height, format);
+
+    int const min_width = 4800;
+    int const min_height = 3200;
+
+    mir_surface_spec_set_min_width(spec, min_width);
+    mir_surface_spec_set_min_height(spec, min_height);
+    surface = mir_surface_create_sync(spec);
+    mir_surface_spec_release(spec);
+
+    auto const buffer_stream = mir_surface_get_buffer_stream(surface);
+
+    MirGraphicsRegion graphics_region;
+    mir_buffer_stream_get_graphics_region(buffer_stream, &graphics_region);
+    EXPECT_THAT(graphics_region.width, Ge(min_width));
+    EXPECT_THAT(graphics_region.height, Ge(min_height));
+
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
 TEST_F(ClientLibrary, receives_surface_dpi_value)
 {
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);

=== modified file 'tests/acceptance-tests/test_surface_modifications.cpp'
--- tests/acceptance-tests/test_surface_modifications.cpp	2015-04-10 13:38:16 +0000
+++ tests/acceptance-tests/test_surface_modifications.cpp	2015-04-15 11:10:33 +0000
@@ -18,13 +18,16 @@
 
 #include "mir_test_framework/connected_client_with_a_surface.h"
 
+#include "mir/events/event_builders.h"
 #include "mir/shell/shell_wrapper.h"
 #include "mir/scene/session.h"
 #include "mir/scene/surface.h"
 #include "mir/scene/null_surface_observer.h"
 
 #include "mir_test/fake_shared.h"
+#include "mir_test/signal.h"
 
+namespace mev = mir::events;
 namespace mf = mir::frontend;
 namespace mtf = mir_test_framework;
 namespace ms = mir::scene;
@@ -76,11 +79,72 @@
 
         mtf::ConnectedClientWithASurface::SetUp();
 
-        auto const scene_surface = shell->latest_surface.lock();
+        shell_surface = shell->latest_surface;
+        auto const scene_surface = shell_surface.lock();
         scene_surface->add_observer(mt::fake_shared(surface_observer));
+
+        // Swap buffers to ensure surface is visible for event based tests
+        mir_buffer_stream_swap_buffers_sync(mir_surface_get_buffer_stream(surface));
+    }
+
+    void generate_alt_click_at(Point const& click_position)
+    {
+        MirInputDeviceId const device_id{7};
+        int64_t const timestamp{39};
+        auto const modifiers = mir_input_event_modifier_alt;
+        std::vector<MirPointerButton> depressed_buttons{mir_pointer_button_tertiary};
+
+        auto const x_axis_value = click_position.x.as_float();
+        auto const y_axis_value = click_position.y.as_float();
+        auto const hscroll_value = 0.0;
+        auto const vscroll_value = 0.0;
+        auto const action = mir_pointer_action_button_down;
+
+        auto const click_event = mev::make_event(device_id, timestamp, modifiers,
+            action, depressed_buttons, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
+
+        server.the_shell()->handle(*click_event);
+    }
+
+    void generate_alt_move_to(Point const& drag_position)
+    {
+        MirInputDeviceId const device_id{7};
+        int64_t const timestamp{39};
+        auto const modifiers = mir_input_event_modifier_alt;
+        std::vector<MirPointerButton> depressed_buttons{mir_pointer_button_tertiary};
+
+        auto const x_axis_value = drag_position.x.as_float();
+        auto const y_axis_value = drag_position.y.as_float();
+        auto const hscroll_value = 0.0;
+        auto const vscroll_value = 0.0;
+        auto const action = mir_pointer_action_motion;
+
+        auto const drag_event = mev::make_event(device_id, timestamp, modifiers,
+            action, depressed_buttons, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
+
+        server.the_shell()->handle(*drag_event);
+    }
+
+    void ensure_server_has_processed_setup()
+    {
+        mt::Signal server_ready;
+
+        auto const new_title = __PRETTY_FUNCTION__;
+
+        EXPECT_CALL(surface_observer, renamed(StrEq(new_title))).
+            WillOnce(InvokeWithoutArgs([&]{ server_ready.raise(); }));
+
+        auto const spec = mir_connection_create_spec_for_changes(connection);
+
+        mir_surface_spec_set_name(spec, new_title);
+        mir_surface_apply_spec(surface, spec);
+        mir_surface_spec_release(spec);
+
+        server_ready.wait();
     }
 
     MockSurfaceObserver surface_observer;
+    std::weak_ptr<ms::Surface> shell_surface;
 };
 
 MATCHER_P(WidthEq, value, "")
@@ -160,3 +224,47 @@
     mir_surface_apply_spec(surface, spec);
     mir_surface_spec_release(spec);
 }
+
+TEST_F(SurfaceModifications, surface_spec_min_width_is_respected)
+{
+    auto const min_width = 17;
+
+    {
+        auto const spec = mir_connection_create_spec_for_changes(connection);
+        mir_surface_spec_set_min_width(spec, min_width);
+        mir_surface_apply_spec(surface, spec);
+        mir_surface_spec_release(spec);
+    }
+
+    ensure_server_has_processed_setup();
+
+    auto const shell_surface = this->shell_surface.lock();
+    auto const bottom_right = shell_surface->input_bounds().bottom_right() - Displacement{1,1};
+
+    EXPECT_CALL(surface_observer, resized_to(WidthEq(min_width)));
+
+    generate_alt_click_at(bottom_right);
+    generate_alt_move_to(shell_surface->top_left());
+}
+
+TEST_F(SurfaceModifications, surface_spec_min_height_is_respected)
+{
+    auto const min_height = 19;
+
+    {
+        auto const spec = mir_connection_create_spec_for_changes(connection);
+        mir_surface_spec_set_min_height(spec, min_height);
+        mir_surface_apply_spec(surface, spec);
+        mir_surface_spec_release(spec);
+    }
+
+    ensure_server_has_processed_setup();
+
+    auto const shell_surface = this->shell_surface.lock();
+    auto const bottom_right = shell_surface->input_bounds().bottom_right() - Displacement{1,1};
+
+    EXPECT_CALL(surface_observer, resized_to(HeightEq(min_height)));
+
+    generate_alt_click_at(bottom_right);
+    generate_alt_move_to(shell_surface->top_left());
+}