1
=== modified file 'tests/acceptance-tests/test_client_library_errors.cpp'
2
--- tests/acceptance-tests/test_client_library_errors.cpp	2014-11-05 10:17:05 +0000
3
+++ tests/acceptance-tests/test_client_library_errors.cpp	2014-11-18 16:56:14 +0000
4
@@ -25,8 +25,7 @@
5
25
25
6
26
#include "mir_test/validity_matchers.h"
26
#include "mir_test/validity_matchers.h"
7
27
27
10
28
#include "mir_test_framework/in_process_server.h"
28
#include "mir_test_framework/headless_in_process_server.h"
9
29
#include "mir_test_framework/stubbed_server_configuration.h"
11
30
#include "mir_test_framework/using_stub_client_platform.h"
29
#include "mir_test_framework/using_stub_client_platform.h"
12
31
#include "mir_test_framework/stub_client_connection_configuration.h"
30
#include "mir_test_framework/stub_client_connection_configuration.h"
13
32
31
14
@@ -132,19 +131,10 @@
15
132
        return std::make_shared<ConfigurableFailureFactory<failure_set>>();
131
        return std::make_shared<ConfigurableFailureFactory<failure_set>>();
16
133
    }
132
    }
17
134
};
133
};
18
135
19
136
class ClientLibraryErrors : public mtf::InProcessServer
20
137
{
21
138
private:
22
139
    mtf::StubbedServerConfiguration config;
23
140
24
141
    mir::DefaultServerConfiguration &server_config() override
25
142
    {
26
143
        return config;
27
144
    }
28
145
};
29
146
}
134
}
30
147
135
31
136
using ClientLibraryErrors = mtf::HeadlessInProcessServer;
32
137
33
148
TEST_F(ClientLibraryErrors, exception_in_client_configuration_constructor_generates_error)
138
TEST_F(ClientLibraryErrors, exception_in_client_configuration_constructor_generates_error)
34
149
{
139
{
35
150
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::the_client_platform_factory>> stubby;
140
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::the_client_platform_factory>> stubby;
36
151
141
37
=== modified file 'tests/acceptance-tests/test_client_surface_events.cpp'
38
--- tests/acceptance-tests/test_client_surface_events.cpp	2014-10-27 22:31:16 +0000
39
+++ tests/acceptance-tests/test_client_surface_events.cpp	2014-11-18 16:56:14 +0000
40
@@ -24,8 +24,7 @@
41
24
#include "mir/scene/surface.h"
24
#include "mir/scene/surface.h"
42
25
#include "mir/scene/surface_creation_parameters.h"
25
#include "mir/scene/surface_creation_parameters.h"
43
26
26
46
27
#include "mir_test_framework/stubbed_server_configuration.h"
27
#include "mir_test_framework/connected_client_with_a_surface.h"
45
28
#include "mir_test_framework/basic_client_server_fixture.h"
47
29
28
48
30
#include <gtest/gtest.h>
29
#include <gtest/gtest.h>
49
31
#include <gmock/gmock.h>
30
#include <gmock/gmock.h>
50
@@ -60,32 +59,7 @@
51
60
    std::shared_ptr<ms::Surface> latest_surface;
59
    std::shared_ptr<ms::Surface> latest_surface;
52
61
};
60
};
53
62
61
80
63
struct MyConfig : mtf::StubbedServerConfiguration
62
struct ClientSurfaceEvents : mtf::ConnectedClientWithASurface
55
64
{
56
65
    std::shared_ptr<ms::SurfaceCoordinator> wrap_surface_coordinator(
57
66
        std::shared_ptr<ms::SurfaceCoordinator> const& wrapped) override
58
67
    {
59
68
        auto const msc = std::make_shared<MockSurfaceCoordinator>(wrapped);
60
69
        mock_surface_coordinator = msc;
61
70
        return msc;
62
71
    }
63
72
64
73
    std::shared_ptr<MockSurfaceCoordinator> the_mock_surface_coordinator() const
65
74
    {
66
75
        return mock_surface_coordinator.lock();
67
76
    }
68
77
69
78
    std::shared_ptr<ms::Surface> the_latest_surface() const
70
79
    {
71
80
        return the_mock_surface_coordinator()->latest_surface;
72
81
    }
73
82
74
83
    std::weak_ptr<MockSurfaceCoordinator> mock_surface_coordinator;
75
84
};
76
85
77
86
using BasicClientServerFixture = mtf::BasicClientServerFixture<MyConfig>;
78
87
79
88
struct ClientSurfaceEvents : BasicClientServerFixture
81
89
{
63
{
82
90
    MirSurfaceParameters const request_params
64
    MirSurfaceParameters const request_params
83
91
    {
65
    {
84
@@ -96,7 +70,6 @@
85
96
        mir_display_output_id_invalid
70
        mir_display_output_id_invalid
86
97
    };
71
    };
87
98
72
88
99
    MirSurface* surface{nullptr};
89
100
    MirSurface* other_surface;
73
    MirSurface* other_surface;
90
101
74
91
102
    std::mutex last_event_mutex;
75
    std::mutex last_event_mutex;
92
@@ -139,14 +112,31 @@
93
139
        last_event_surface = nullptr;
112
        last_event_surface = nullptr;
94
140
    }
113
    }
95
141
114
96
115
    std::shared_ptr<MockSurfaceCoordinator> the_mock_surface_coordinator() const
97
116
    {
98
117
        return mock_surface_coordinator.lock();
99
118
    }
100
119
101
120
    std::shared_ptr<ms::Surface> the_latest_surface() const
102
121
    {
103
122
        return the_mock_surface_coordinator()->latest_surface;
104
123
    }
105
124
106
142
    void SetUp() override
125
    void SetUp() override
107
143
    {
126
    {
111
144
        BasicClientServerFixture::SetUp();
127
        server.wrap_surface_coordinator([&](std::shared_ptr<ms::SurfaceCoordinator> const& wrapped)
112
145
128
            -> std::shared_ptr<ms::SurfaceCoordinator>
113
146
        surface = mir_connection_create_surface_sync(connection, &request_params);
129
        {
114
130
            auto const msc = std::make_shared<MockSurfaceCoordinator>(wrapped);
115
131
            mock_surface_coordinator = msc;
116
132
            return msc;
117
133
        });
118
134
119
135
        mtf::ConnectedClientWithASurface::SetUp();
120
136
121
147
        mir_surface_set_event_handler(surface, &delegate);
137
        mir_surface_set_event_handler(surface, &delegate);
122
148
138
124
149
        scene_surface = server_configuration.the_latest_surface();
139
        scene_surface = the_latest_surface();
125
150
140
126
151
        other_surface = mir_connection_create_surface_sync(connection, &request_params);
141
        other_surface = mir_connection_create_surface_sync(connection, &request_params);
127
152
        mir_surface_set_event_handler(other_surface, nullptr);
142
        mir_surface_set_event_handler(other_surface, nullptr);
128
@@ -158,10 +148,11 @@
129
158
    {
148
    {
130
159
        mir_surface_release_sync(other_surface);
149
        mir_surface_release_sync(other_surface);
131
160
        scene_surface.reset();
150
        scene_surface.reset();
132
161
        mir_surface_release_sync(surface);
133
162
151
135
163
        BasicClientServerFixture::TearDown();
152
        mtf::ConnectedClientWithASurface::TearDown();
136
164
    }
153
    }
137
154
138
155
    std::weak_ptr<MockSurfaceCoordinator> mock_surface_coordinator;
139
165
};
156
};
140
166
}
157
}
141
167
158
142
168
159
143
=== modified file 'tests/acceptance-tests/test_client_surface_swap_buffers.cpp'
144
--- tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2014-11-18 03:21:20 +0000
145
+++ tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2014-11-18 16:56:14 +0000
146
@@ -18,7 +18,7 @@
147
18
18
148
19
#include "mir_toolkit/mir_client_library.h"
19
#include "mir_toolkit/mir_client_library.h"
149
20
20
151
21
#include "mir_test_framework/connected_client_headless_server.h"
21
#include "mir_test_framework/connected_client_with_a_surface.h"
152
22
#include "mir_test_doubles/null_display_buffer_compositor_factory.h"
22
#include "mir_test_doubles/null_display_buffer_compositor_factory.h"
153
23
#include "mir_test/signal.h"
23
#include "mir_test/signal.h"
154
24
24
155
@@ -38,35 +38,7 @@
156
38
    buffers_swapped->raise();
38
    buffers_swapped->raise();
157
39
}
39
}
158
40
40
188
41
struct ConnectedClientWithASurface : mtf::ConnectedClientHeadlessServer
41
struct SurfaceSwapBuffers : mtf::ConnectedClientWithASurface
160
42
{
161
43
    MirSurface* surface{nullptr};
162
44
163
45
    void SetUp() override
164
46
    {
165
47
        mtf::ConnectedClientHeadlessServer::SetUp();
166
48
167
49
        MirSurfaceParameters request_params =
168
50
        {
169
51
            __PRETTY_FUNCTION__,
170
52
            640, 480,
171
53
            mir_pixel_format_abgr_8888,
172
54
            mir_buffer_usage_hardware,
173
55
            mir_display_output_id_invalid
174
56
        };
175
57
176
58
        surface = mir_connection_create_surface_sync(connection, &request_params);
177
59
        ASSERT_TRUE(mir_surface_is_valid(surface));
178
60
    }
179
61
180
62
    void TearDown() override
181
63
    {
182
64
        mir_surface_release_sync(surface);
183
65
        mtf::ConnectedClientHeadlessServer::TearDown();
184
66
    }
185
67
};
186
68
187
69
struct SurfaceSwapBuffers : ConnectedClientWithASurface
189
70
{
42
{
190
71
    void SetUp() override
43
    void SetUp() override
191
72
    {
44
    {
192
73
45
193
=== modified file 'tests/acceptance-tests/test_server_disconnect.cpp'
194
--- tests/acceptance-tests/test_server_disconnect.cpp	2014-11-11 15:50:11 +0000
195
+++ tests/acceptance-tests/test_server_disconnect.cpp	2014-11-18 16:56:14 +0000
196
@@ -18,8 +18,9 @@
197
18
18
198
19
#include "mir_toolkit/mir_client_library.h"
19
#include "mir_toolkit/mir_client_library.h"
199
20
20
201
21
#include "mir_test_framework/display_server_test_fixture.h"
21
#include "mir_test_framework/interprocess_client_server_test.h"
202
22
#include "mir_test_framework/cross_process_sync.h"
22
#include "mir_test_framework/cross_process_sync.h"
203
23
#include "mir_test_framework/process.h"
204
23
#include "mir_test/cross_process_action.h"
24
#include "mir_test/cross_process_action.h"
205
24
25
206
25
#include <gtest/gtest.h>
26
#include <gtest/gtest.h>
207
@@ -30,10 +31,17 @@
208
30
namespace mtf = mir_test_framework;
31
namespace mtf = mir_test_framework;
209
31
namespace mt = mir::test;
32
namespace mt = mir::test;
210
32
33
211
33
using ServerDisconnect = mtf::BespokeDisplayServerTestFixture;
212
34
213
35
namespace
34
namespace
214
36
{
35
{
215
36
struct ServerDisconnect : mtf::InterprocessClientServerTest
216
37
{
217
38
    void SetUp() override
218
39
    {
219
40
        mtf::InterprocessClientServerTest::SetUp();
220
41
        run_in_server([]{});
221
42
    }
222
43
};
223
44
224
37
struct MockEventHandler
45
struct MockEventHandler
225
38
{
46
{
226
39
    MOCK_METHOD1(handle, void(MirLifecycleState transition));
47
    MOCK_METHOD1(handle, void(MirLifecycleState transition));
227
@@ -44,61 +52,132 @@
228
44
    }
52
    }
229
45
};
53
};
230
46
54
264
47
struct MyTestingClientConfiguration : mtf::TestingClientConfiguration
55
void null_lifecycle_callback(MirConnection*, MirLifecycleState, void*)
265
48
{
56
{
266
49
    void exec() override
57
}
267
50
    {
58
}
268
51
        static MirSurfaceParameters const params =
59
269
52
            { __PRETTY_FUNCTION__, 33, 45, mir_pixel_format_abgr_8888,
60
TEST_F(ServerDisconnect, is_detected_by_client)
270
53
              mir_buffer_usage_hardware, mir_display_output_id_invalid };
61
{
238
54
239
55
        MockEventHandler mock_event_handler;
240
56
241
57
        auto connection = mir_connect_sync(mtf::test_socket_file().c_str() , __PRETTY_FUNCTION__);
242
58
        mir_connection_set_lifecycle_event_callback(connection, &MockEventHandler::handle, &mock_event_handler);
243
59
        auto surface = mir_connection_create_surface_sync(connection, &params);
244
60
245
61
        std::atomic<bool> signalled(false);
246
62
247
63
        EXPECT_CALL(mock_event_handler, handle(mir_lifecycle_connection_lost)).Times(1).
248
64
            WillOnce(testing::InvokeWithoutArgs([&] { signalled.store(true); }));
249
65
250
66
        sync.signal_ready();
251
67
252
68
        using clock = std::chrono::high_resolution_clock;
253
69
254
70
        auto time_limit = clock::now() + std::chrono::seconds(2);
255
71
256
72
        while (!signalled.load() && clock::now() < time_limit)
257
73
        {
258
74
            mir_surface_swap_buffers_sync(surface);
259
75
        }
260
76
        mir_surface_release_sync(surface);
261
77
        mir_connection_release(connection);
262
78
    }
263
79
271
80
    mtf::CrossProcessSync sync;
62
    mtf::CrossProcessSync sync;
293
81
};
63
294
82
64
    auto const client = new_client_process([&]
295
83
struct DisconnectingTestingClientConfiguration : mtf::TestingClientConfiguration
65
        {
296
84
{
66
            static MirSurfaceParameters const params =
297
85
    void exec() override
67
                { __PRETTY_FUNCTION__, 33, 45, mir_pixel_format_abgr_8888,
298
86
    {
68
                  mir_buffer_usage_hardware, mir_display_output_id_invalid };
299
87
        MirConnection* connection{nullptr};
69
300
88
70
            MockEventHandler mock_event_handler;
301
89
        connect.exec([&] {
71
302
90
            connection = mir_connect_sync(mtf::test_socket_file().c_str() , __PRETTY_FUNCTION__);
72
            auto connection = mir_connect_sync(mtf::test_socket_file().c_str() , __PRETTY_FUNCTION__);
303
91
            EXPECT_TRUE(mir_connection_is_valid(connection));
73
            mir_connection_set_lifecycle_event_callback(connection, &MockEventHandler::handle, &mock_event_handler);
304
92
            /*
74
            auto surface = mir_connection_create_surface_sync(connection, &params);
305
93
             * Set a null callback to avoid killing the process
75
306
94
             * (default callback raises SIGHUP).
76
            std::atomic<bool> signalled(false);
307
95
             */
77
308
96
            mir_connection_set_lifecycle_event_callback(connection,
78
            EXPECT_CALL(mock_event_handler, handle(mir_lifecycle_connection_lost)).Times(1).
309
97
                                                        null_lifecycle_callback,
79
                WillOnce(testing::InvokeWithoutArgs([&] { signalled.store(true); }));
310
98
                                                        nullptr);
80
311
99
        });
81
            sync.signal_ready();
312
100
82
313
101
        create_surface.exec([&] {
83
            using clock = std::chrono::high_resolution_clock;
314
84
315
85
            auto time_limit = clock::now() + std::chrono::seconds(2);
316
86
317
87
            while (!signalled.load() && clock::now() < time_limit)
318
88
            {
319
89
                mir_surface_swap_buffers_sync(surface);
320
90
            }
321
91
            mir_surface_release_sync(surface);
322
92
            mir_connection_release(connection);
323
93
        });
324
94
325
95
    if (is_test_process())
326
96
    {
327
97
        sync.wait_for_signal_ready_for();
328
98
        stop_server();
329
99
    }
330
100
}
331
101
332
102
TEST_F(ServerDisconnect, doesnt_stop_client_calling_API_functions)
333
103
{
334
104
    mt::CrossProcessAction connect;
335
105
    mt::CrossProcessAction create_surface;
336
106
    mt::CrossProcessAction configure_display;
337
107
    mt::CrossProcessAction disconnect;
338
108
339
109
    auto const client = new_client_process([&]
340
110
        {
341
111
            MirConnection* connection{nullptr};
342
112
343
113
            connect.exec([&] {
344
114
                connection = mir_connect_sync(mtf::test_socket_file().c_str() , __PRETTY_FUNCTION__);
345
115
                EXPECT_TRUE(mir_connection_is_valid(connection));
346
116
                /*
347
117
                 * Set a null callback to avoid killing the process
348
118
                 * (default callback raises SIGHUP).
349
119
                 */
350
120
                mir_connection_set_lifecycle_event_callback(connection,
351
121
                                                            null_lifecycle_callback,
352
122
                                                            nullptr);
353
123
            });
354
124
355
125
            MirSurface* surf;
356
126
357
127
            create_surface.exec([&] {
358
128
                MirSurfaceParameters const parameters =
359
129
                {
360
130
                    __PRETTY_FUNCTION__,
361
131
                    1, 1,
362
132
                    mir_pixel_format_abgr_8888,
363
133
                    mir_buffer_usage_hardware,
364
134
                    mir_display_output_id_invalid
365
135
                };
366
136
                surf = mir_connection_create_surface_sync(connection, &parameters);
367
137
            });
368
138
369
139
            configure_display.exec([&] {
370
140
                auto config = mir_connection_create_display_config(connection);
371
141
                mir_wait_for(mir_connection_apply_display_config(connection, config));
372
142
                mir_display_config_destroy(config);
373
143
            });
374
144
375
145
            disconnect.exec([&] {
376
146
                mir_surface_release_sync(surf);
377
147
                mir_connection_release(connection);
378
148
            });
379
149
        });
380
150
381
151
    if (is_test_process())
382
152
    {
383
153
        connect();
384
154
        stop_server();
385
155
        /* While trying to create a surface the connection break will be detected */
386
156
        create_surface();
387
157
388
158
        /* Trying to configure the display shouldn't block */
389
159
        configure_display();
390
160
        /* Trying to disconnect at this point shouldn't block */
391
161
        disconnect();
392
162
    }
393
163
}
394
164
395
165
TEST_F(ServerDisconnect, causes_client_to_terminate_by_default)
396
166
{
397
167
    mt::CrossProcessAction connect;
398
168
    mtf::CrossProcessSync create_surface_sync;
399
169
400
170
    auto const client = new_client_process([&]
401
171
        {
402
172
            MirConnection* connection{nullptr};
403
173
404
174
            connect.exec([&] {
405
175
                connection = mir_connect_sync(mtf::test_socket_file().c_str() , __PRETTY_FUNCTION__);
406
176
                EXPECT_TRUE(mir_connection_is_valid(connection));
407
177
            });
408
178
409
179
            create_surface_sync.wait_for_signal_ready_for();
410
180
411
102
            MirSurfaceParameters const parameters =
181
            MirSurfaceParameters const parameters =
412
103
            {
182
            {
413
104
                __PRETTY_FUNCTION__,
183
                __PRETTY_FUNCTION__,
414
@@ -107,129 +186,26 @@
415
107
                mir_buffer_usage_hardware,
186
                mir_buffer_usage_hardware,
416
108
                mir_display_output_id_invalid
187
                mir_display_output_id_invalid
417
109
            };
188
            };
429
110
            surf = mir_connection_create_surface_sync(connection, &parameters);
189
            mir_connection_create_surface_sync(connection, &parameters);
430
111
        });
190
420
112
421
113
        configure_display.exec([&] {
422
114
            auto config = mir_connection_create_display_config(connection);
423
115
            mir_wait_for(mir_connection_apply_display_config(connection, config));
424
116
            mir_display_config_destroy(config);
425
117
        });
426
118
427
119
        disconnect.exec([&] {
428
120
            mir_surface_release_sync(surf);
431
121
            mir_connection_release(connection);
191
            mir_connection_release(connection);
432
122
        });
192
        });
531
123
    }
193
532
124
194
    if (is_test_process())
533
125
    static void null_lifecycle_callback(MirConnection*, MirLifecycleState, void*)
195
    {
534
126
    {
196
        connect();
535
127
    }
197
        stop_server();
438
128
439
129
    mt::CrossProcessAction connect;
440
130
    mt::CrossProcessAction create_surface;
441
131
    mt::CrossProcessAction configure_display;
442
132
    mt::CrossProcessAction disconnect;
443
133
private:
444
134
    MirSurface* surf;
445
135
};
446
136
447
137
/*
448
138
 * This client will self-terminate on server connection break (through the default
449
139
 * lifecycle handler).
450
140
 */
451
141
struct TerminatingTestingClientConfiguration : mtf::TestingClientConfiguration
452
142
{
453
143
    void exec() override
454
144
    {
455
145
        MirConnection* connection{nullptr};
456
146
457
147
        connect.exec([&] {
458
148
            connection = mir_connect_sync(mtf::test_socket_file().c_str() , __PRETTY_FUNCTION__);
459
149
            EXPECT_TRUE(mir_connection_is_valid(connection));
460
150
        });
461
151
462
152
        create_surface_sync.wait_for_signal_ready_for();
463
153
464
154
        MirSurfaceParameters const parameters =
465
155
        {
466
156
            __PRETTY_FUNCTION__,
467
157
            1, 1,
468
158
            mir_pixel_format_abgr_8888,
469
159
            mir_buffer_usage_hardware,
470
160
            mir_display_output_id_invalid
471
161
        };
472
162
        mir_connection_create_surface_sync(connection, &parameters);
473
163
474
164
        mir_connection_release(connection);
475
165
    }
476
166
477
167
    mt::CrossProcessAction connect;
478
168
    mtf::CrossProcessSync create_surface_sync;
479
169
};
480
170
}
481
171
482
172
TEST_F(ServerDisconnect, client_detects_server_shutdown)
483
173
{
484
174
    TestingServerConfiguration server_config;
485
175
    launch_server_process(server_config);
486
176
487
177
    MyTestingClientConfiguration client_config;
488
178
    launch_client_process(client_config);
489
179
490
180
    run_in_test_process([this, &client_config]
491
181
    {
492
182
        client_config.sync.wait_for_signal_ready_for();
493
183
        shutdown_server_process();
494
184
    });
495
185
}
496
186
497
187
TEST_F(ServerDisconnect, client_can_call_connection_functions_after_connection_break_is_detected)
498
188
{
499
189
    TestingServerConfiguration server_config;
500
190
    launch_server_process(server_config);
501
191
502
192
    DisconnectingTestingClientConfiguration client_config;
503
193
    launch_client_process(client_config);
504
194
505
195
    run_in_test_process([this, &client_config]
506
196
    {
507
197
        client_config.connect();
508
198
        shutdown_server_process();
509
199
        /* While trying to create a surface the connection break will be detected */
510
200
        client_config.create_surface();
511
201
512
202
        /* Trying to configure the display shouldn't block */
513
203
        client_config.configure_display();
514
204
        /* Trying to disconnect at this point shouldn't block */
515
205
        client_config.disconnect();
516
206
    });
517
207
}
518
208
519
209
TEST_F(ServerDisconnect, causes_client_to_terminate_by_default)
520
210
{
521
211
    TestingServerConfiguration server_config;
522
212
    launch_server_process(server_config);
523
213
524
214
    TerminatingTestingClientConfiguration client_config;
525
215
    launch_client_process(client_config);
526
216
527
217
    run_in_test_process([this, &client_config]
528
218
    {
529
219
        client_config.connect();
530
220
        shutdown_server_process();
536
221
198
537
222
        /*
199
        /*
538
223
         * While trying to create a surface the connection break will be detected
200
         * While trying to create a surface the connection break will be detected
539
224
         * and the client should self-terminate.
201
         * and the client should self-terminate.
540
225
         */
202
         */
542
226
        client_config.create_surface_sync.signal_ready();
203
        create_surface_sync.signal_ready();
543
227
204
546
228
        auto const client_results = wait_for_shutdown_client_processes();
205
        auto const client_result = client->wait_for_termination();
545
229
        ASSERT_EQ(1, client_results.size());
547
230
        EXPECT_EQ(mtf::TerminationReason::child_terminated_by_signal,
206
        EXPECT_EQ(mtf::TerminationReason::child_terminated_by_signal,
550
231
                  client_results[0].reason);
207
                  client_result.reason);
551
232
        int sig = client_results[0].signal;
208
        int sig = client_result.signal;
552
233
        EXPECT_TRUE(sig == SIGHUP || sig == SIGKILL /* (Valgrind) */);
209
        EXPECT_TRUE(sig == SIGHUP || sig == SIGKILL /* (Valgrind) */);
554
234
    });
210
    }
555
235
}
211
}
556
236
212
557
=== added file 'tests/include/mir_test_framework/connected_client_with_a_surface.h'
558
--- tests/include/mir_test_framework/connected_client_with_a_surface.h	1970-01-01 00:00:00 +0000
559
+++ tests/include/mir_test_framework/connected_client_with_a_surface.h	2014-11-18 16:56:14 +0000
560
@@ -0,0 +1,36 @@
561
1
/*
562
2
 * Copyright © 2014 Canonical Ltd.
563
3
 *
564
4
 * This program is free software: you can redistribute it and/or modify it
565
5
 * under the terms of the GNU General Public License version 3,
566
6
 * as published by the Free Software Foundation.
567
7
 *
568
8
 * This program is distributed in the hope that it will be useful,
569
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
570
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
571
11
 * GNU General Public License for more details.
572
12
 *
573
13
 * You should have received a copy of the GNU General Public License
574
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
575
15
 *
576
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
577
17
 */
578
18
579
19
#ifndef MIR_TEST_FRAMEWORK_CONNECTED_CLIENT_WITH_A_SURFACE_H_
580
20
#define MIR_TEST_FRAMEWORK_CONNECTED_CLIENT_WITH_A_SURFACE_H_
581
21
582
22
#include "mir_test_framework/connected_client_headless_server.h"
583
23
584
24
namespace mir_test_framework
585
25
{
586
26
struct ConnectedClientWithASurface : ConnectedClientHeadlessServer
587
27
{
588
28
    MirSurface* surface{nullptr};
589
29
590
30
    void SetUp() override;
591
31
592
32
    void TearDown() override;
593
33
};
594
34
}
595
35
596
36
#endif /* MIR_TEST_FRAMEWORK_CONNECTED_CLIENT_WITH_A_SURFACE_H_ */
597
0
37
598
=== modified file 'tests/include/mir_test_framework/interprocess_client_server_test.h'
599
--- tests/include/mir_test_framework/interprocess_client_server_test.h	2014-11-18 03:21:20 +0000
600
+++ tests/include/mir_test_framework/interprocess_client_server_test.h	2014-11-18 16:56:14 +0000
601
@@ -25,6 +25,7 @@
602
25
namespace mir_test_framework
25
namespace mir_test_framework
603
26
{
26
{
604
27
class Process;
27
class Process;
605
28
class Result;
606
28
29
607
29
class InterprocessClientServerTest : public HeadlessTest
30
class InterprocessClientServerTest : public HeadlessTest
608
30
{
31
{
609
@@ -39,6 +40,8 @@
610
39
40
611
40
    void run_in_client(std::function<void()> const& client_code);
41
    void run_in_client(std::function<void()> const& client_code);
612
41
42
613
43
    auto new_client_process(std::function<void()> const& client_code) -> std::shared_ptr<Process>;
614
44
615
42
    bool is_test_process() const;
45
    bool is_test_process() const;
616
43
46
617
44
    pid_t client_pid() const { return client_process_id; }
47
    pid_t client_pid() const { return client_process_id; }
618
@@ -50,8 +53,12 @@
619
50
53
620
51
    void expect_server_signalled(int signal);
54
    void expect_server_signalled(int signal);
621
52
55
622
56
    void stop_server();
623
57
624
53
    bool sigkill_server_process();
58
    bool sigkill_server_process();
625
54
59
626
60
    Result wait_for_shutdown_server_process();
627
61
628
55
private:
62
private:
629
56
63
630
57
    pid_t test_process_id{getpid()};
64
    pid_t test_process_id{getpid()};
631
58
65
632
=== modified file 'tests/mir_test_framework/CMakeLists.txt'
633
--- tests/mir_test_framework/CMakeLists.txt	2014-11-18 03:21:20 +0000
634
+++ tests/mir_test_framework/CMakeLists.txt	2014-11-18 16:56:14 +0000
635
@@ -15,6 +15,7 @@
636
15
  executable_path.cpp
15
  executable_path.cpp
637
16
  command_line_server_configuration.cpp
16
  command_line_server_configuration.cpp
638
17
  connected_client_headless_server.cpp
17
  connected_client_headless_server.cpp
639
18
  connected_client_with_a_surface.cpp
640
18
  cross_process_sync.cpp
19
  cross_process_sync.cpp
641
19
  headless_in_process_server.cpp
20
  headless_in_process_server.cpp
642
20
  headless_test.cpp
21
  headless_test.cpp
643
21
22
644
=== added file 'tests/mir_test_framework/connected_client_with_a_surface.cpp'
645
--- tests/mir_test_framework/connected_client_with_a_surface.cpp	1970-01-01 00:00:00 +0000
646
+++ tests/mir_test_framework/connected_client_with_a_surface.cpp	2014-11-18 16:56:14 +0000
647
@@ -0,0 +1,44 @@
648
1
/*
649
2
 * Copyright © 2014 Canonical Ltd.
650
3
 *
651
4
 * This program is free software: you can redistribute it and/or modify it
652
5
 * under the terms of the GNU General Public License version 3,
653
6
 * as published by the Free Software Foundation.
654
7
 *
655
8
 * This program is distributed in the hope that it will be useful,
656
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
657
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
658
11
 * GNU General Public License for more details.
659
12
 *
660
13
 * You should have received a copy of the GNU General Public License
661
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
662
15
 *
663
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
664
17
 */
665
18
666
19
#include "mir_test_framework/connected_client_with_a_surface.h"
667
20
668
21
namespace mtf = mir_test_framework;
669
22
670
23
void mtf::ConnectedClientWithASurface::SetUp()
671
24
{
672
25
    ConnectedClientHeadlessServer::SetUp();
673
26
674
27
    MirSurfaceParameters request_params =
675
28
    {
676
29
        __PRETTY_FUNCTION__,
677
30
        640, 480,
678
31
        mir_pixel_format_abgr_8888,
679
32
        mir_buffer_usage_hardware,
680
33
        mir_display_output_id_invalid
681
34
    };
682
35
683
36
    surface = mir_connection_create_surface_sync(connection, &request_params);
684
37
    ASSERT_TRUE(mir_surface_is_valid(surface));
685
38
}
686
39
687
40
void mtf::ConnectedClientWithASurface::TearDown()
688
41
{
689
42
    mir_surface_release_sync(surface);
690
43
    ConnectedClientHeadlessServer::TearDown();
691
44
}
692
0
45
693
=== modified file 'tests/mir_test_framework/interprocess_client_server_test.cpp'
694
--- tests/mir_test_framework/interprocess_client_server_test.cpp	2014-11-18 03:21:20 +0000
695
+++ tests/mir_test_framework/interprocess_client_server_test.cpp	2014-11-18 16:56:14 +0000
696
@@ -82,8 +82,20 @@
697
82
82
698
83
void mtf::InterprocessClientServerTest::run_in_client(std::function<void()> const& client_code)
83
void mtf::InterprocessClientServerTest::run_in_client(std::function<void()> const& client_code)
699
84
{
84
{
700
85
    auto const client_process = new_client_process(client_code);
701
86
702
85
    if (test_process_id != getpid()) return;
87
    if (test_process_id != getpid()) return;
703
86
88
704
89
    Result result = client_process->wait_for_termination();
705
90
    EXPECT_THAT(result.exit_code, Eq(EXIT_SUCCESS));
706
91
}
707
92
708
93
auto mtf::InterprocessClientServerTest::new_client_process(std::function<void()> const& client_code)
709
94
-> std::shared_ptr<Process>
710
95
{
711
96
    if (test_process_id != getpid())
712
97
        return std::shared_ptr<Process>{};
713
98
714
87
    pid_t pid = fork();
99
    pid_t pid = fork();
715
88
100
716
89
    if (pid < 0)
101
    if (pid < 0)
717
@@ -96,13 +108,12 @@
718
96
        process_tag = "client";
108
        process_tag = "client";
719
97
        add_to_environment("MIR_SOCKET", mir_test_socket);
109
        add_to_environment("MIR_SOCKET", mir_test_socket);
720
98
        client_code();
110
        client_code();
721
111
        return std::shared_ptr<Process>{};
722
99
    }
112
    }
723
100
    else
113
    else
724
101
    {
114
    {
725
102
        client_process_id = pid;
115
        client_process_id = pid;
729
103
        auto const client_process = std::make_shared<Process>(pid);
116
        return std::make_shared<Process>(pid);
727
104
        Result result = client_process->wait_for_termination();
728
105
        EXPECT_THAT(result.exit_code, Eq(EXIT_SUCCESS));
730
106
    }
117
    }
731
107
}
118
}
732
108
119
733
@@ -116,7 +127,16 @@
734
116
    if (server_process_id == getpid())
127
    if (server_process_id == getpid())
735
117
    {
128
    {
736
118
        shutdown_sync.wait_for_signal_ready_for();
129
        shutdown_sync.wait_for_signal_ready_for();
738
119
        stop_server();
130
    }
739
131
740
132
    stop_server();
741
133
}
742
134
743
135
void mtf::InterprocessClientServerTest::stop_server()
744
136
{
745
137
    if (server_process_id == getpid())
746
138
    {
747
139
        HeadlessTest::stop_server();
748
120
    }
140
    }
749
121
141
750
122
    if (test_process_id != getpid()) return;
142
    if (test_process_id != getpid()) return;
751
@@ -156,9 +176,19 @@
752
156
        throw std::logic_error("No server process to kill");
176
        throw std::logic_error("No server process to kill");
753
157
177
754
158
    server_process->kill();
178
    server_process->kill();
757
159
    auto result = server_process->wait_for_termination();
179
    auto result = wait_for_shutdown_server_process();
756
160
    server_process.reset();
758
161
180
759
162
    return result.reason == TerminationReason::child_terminated_by_signal &&
181
    return result.reason == TerminationReason::child_terminated_by_signal &&
760
163
           result.signal == SIGKILL;
182
           result.signal == SIGKILL;
761
164
}
183
}
762
184
763
185
mtf::Result mtf::InterprocessClientServerTest::wait_for_shutdown_server_process()
764
186
{
765
187
766
188
    if (!server_process)
767
189
        throw std::logic_error("No server process to monitor");
768
190
769
191
    Result result = server_process->wait_for_termination();
770
192
    server_process.reset();
771
193
    return result;
772
194
}
Status:	Merged
Approved by:	Cemil Azizoglu on 2014-11-19
Approved revision:	no longer in the source branch.
Merged at revision:	2073
Proposed branch:	lp:~alan-griffiths/mir/migrate-more-acceptances-tests
Merge into:	lp:mir
Diff against target:	772 lines (+303/-256) 9 files modified tests/acceptance-tests/test_client_library_errors.cpp (+3/-13) tests/acceptance-tests/test_client_surface_events.cpp (+26/-35) tests/acceptance-tests/test_client_surface_swap_buffers.cpp (+2/-30) tests/acceptance-tests/test_server_disconnect.cpp (+148/-172) tests/include/mir_test_framework/connected_client_with_a_surface.h (+36/-0) tests/include/mir_test_framework/interprocess_client_server_test.h (+7/-0) tests/mir_test_framework/CMakeLists.txt (+1/-0) tests/mir_test_framework/connected_client_with_a_surface.cpp (+44/-0) tests/mir_test_framework/interprocess_client_server_test.cpp (+36/-6)
To merge this branch:	bzr merge lp:~alan-griffiths/mir/migrate-more-acceptances-tests
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2014-11-19
Cemil Azizoglu (community)			Approve on 2014-11-19
Alexandros Frantzis (community)		2014-11-18	Approve on 2014-11-19
Review via email: mp+242094@code.launchpad.net