← Back to branch summary

~mir-team/mir/liberate-historical-pointer-coordinates

« back to all changes in this revision

Viewing changes to tests/integration-tests/frontend/test_session_mediator_report.cpp

frontend: log the exchange_buffer messages in the session-mediator-report.

Approved by PS Jenkins bot, Cemil Azizoglu, Alexandros Frantzis.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/integration-tests/frontend/test_session_mediator_report.cpp
32
32
 
33
33
namespace
34
34
{
35
 
struct MockApplicationMediatorReport : mf::SessionMediatorReport
 
35
struct MockSessionMediatorReport : mf::SessionMediatorReport
36
36
{
37
 
    MockApplicationMediatorReport()
38
 
    {
39
 
        EXPECT_CALL(*this, session_connect_called(testing::_)).
40
 
            Times(testing::AtLeast(0));
41
 
 
42
 
        EXPECT_CALL(*this, session_create_surface_called(testing::_)).
43
 
            Times(testing::AtLeast(0));
44
 
 
45
 
        EXPECT_CALL(*this, session_next_buffer_called(testing::_)).
46
 
            Times(testing::AtLeast(0));
47
 
 
48
 
        EXPECT_CALL(*this, session_release_surface_called(testing::_)).
49
 
            Times(testing::AtLeast(0));
50
 
 
51
 
        EXPECT_CALL(*this, session_disconnect_called(testing::_)).
52
 
            Times(testing::AtLeast(0));
53
 
 
54
 
        EXPECT_CALL(*this, session_start_prompt_session_called(testing::_, testing::_)).
55
 
            Times(testing::AtLeast(0));
56
 
 
57
 
        EXPECT_CALL(*this, session_stop_prompt_session_called(testing::_)).
58
 
            Times(testing::AtLeast(0));
59
 
    }
60
 
 
61
37
    MOCK_METHOD1(session_connect_called, void (std::string const&));
62
38
    MOCK_METHOD1(session_create_surface_called, void (std::string const&));
63
39
    MOCK_METHOD1(session_next_buffer_called, void (std::string const&));
 
40
    MOCK_METHOD1(session_exchange_buffer_called, void (std::string const&));
64
41
    MOCK_METHOD1(session_release_surface_called, void (std::string const&));
65
42
    MOCK_METHOD1(session_disconnect_called, void (std::string const&));
66
43
    MOCK_METHOD2(session_start_prompt_session_called, void (std::string const&, pid_t));
75
52
 
76
53
const int rpc_timeout_ms{100000};
77
54
 
78
 
typedef BespokeDisplayServerTestFixture ApplicationMediatorReport;
 
55
typedef BespokeDisplayServerTestFixture SessionMediatorReport;
79
56
}
80
57
 
81
 
TEST_F(ApplicationMediatorReport, session_connect_called)
 
58
TEST_F(SessionMediatorReport, session_connect_called)
82
59
{
83
60
    struct Server : TestingServerConfiguration
84
61
    {
85
 
        std::shared_ptr<mf::SessionMediatorReport>
86
 
        the_application_mediator_report()
 
62
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
87
63
        {
88
 
            auto result = std::make_shared<MockApplicationMediatorReport>();
89
 
 
90
 
            EXPECT_CALL(*result, session_connect_called(testing::_)).
91
 
                Times(1);
92
 
 
93
 
            return result;
 
64
            if (!report)
 
65
            {
 
66
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
67
                EXPECT_CALL(*report, session_connect_called(testing::_)).
 
68
                    Times(1);
 
69
            }
 
70
            return report;
94
71
        }
 
72
        std::shared_ptr<MockSessionMediatorReport> report;
95
73
    } server_processing;
96
74
 
97
75
    launch_server_process(server_processing);
100
78
    {
101
79
        void exec()
102
80
        {
103
 
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
 
81
            testing::NiceMock<mt::TestProtobufClient> client(mtf::test_socket_file(), rpc_timeout_ms);
104
82
 
105
83
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
106
84
            EXPECT_CALL(client, connect_done()).
110
88
                0,
111
89
                &client.connect_parameters,
112
90
                &client.connection,
113
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
 
91
                google::protobuf::NewCallback(
 
92
                    static_cast<mt::TestProtobufClient*>(&client),
 
93
                    &mt::TestProtobufClient::connect_done));
114
94
 
115
95
            client.wait_for_connect_done();
116
96
        }
119
99
    launch_client_process(client_process);
120
100
}
121
101
 
122
 
TEST_F(ApplicationMediatorReport, session_create_surface_called)
 
102
TEST_F(SessionMediatorReport, session_create_surface_called)
123
103
{
124
104
    struct Server : TestingServerConfiguration
125
105
    {
126
 
        std::shared_ptr<mf::SessionMediatorReport>
127
 
        the_application_mediator_report()
 
106
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
128
107
        {
129
 
            auto result = std::make_shared<MockApplicationMediatorReport>();
130
 
 
131
 
            EXPECT_CALL(*result, session_create_surface_called(testing::_)).
132
 
                Times(1);
133
 
 
134
 
            return result;
 
108
            if (!report)
 
109
            {
 
110
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
111
                EXPECT_CALL(*report, session_create_surface_called(testing::_)).
 
112
                    Times(1);
 
113
            }
 
114
            return report;
135
115
        }
 
116
        std::shared_ptr<MockSessionMediatorReport> report;
136
117
    } server_processing;
137
 
 
138
118
    launch_server_process(server_processing);
139
119
 
140
120
    struct Client: TestingClientConfiguration
141
121
    {
142
122
        void exec()
143
123
        {
144
 
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
 
124
            testing::NiceMock<mt::TestProtobufClient> client(mtf::test_socket_file(), rpc_timeout_ms);
145
125
 
146
126
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
147
127
            EXPECT_CALL(client, connect_done()).
153
133
                0,
154
134
                &client.connect_parameters,
155
135
                &client.connection,
156
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
 
136
                google::protobuf::NewCallback(
 
137
                    static_cast<mt::TestProtobufClient*>(&client),
 
138
                    &mt::TestProtobufClient::connect_done));
157
139
 
158
140
            client.wait_for_connect_done();
159
141
 
161
143
                0,
162
144
                &client.surface_parameters,
163
145
                &client.surface,
164
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::create_surface_done));
 
146
                google::protobuf::NewCallback(
 
147
                    static_cast<mt::TestProtobufClient*>(&client),
 
148
                    &mt::TestProtobufClient::create_surface_done));
165
149
            client.wait_for_create_surface();
166
150
 
167
151
        }
170
154
    launch_client_process(client_process);
171
155
}
172
156
 
173
 
TEST_F(ApplicationMediatorReport, session_next_buffer_called)
 
157
TEST_F(SessionMediatorReport, session_next_buffer_called)
174
158
{
175
159
    struct Server : TestingServerConfiguration
176
160
    {
177
 
        std::shared_ptr<mf::SessionMediatorReport>
178
 
        the_application_mediator_report()
 
161
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
179
162
        {
180
 
            auto result = std::make_shared<MockApplicationMediatorReport>();
181
 
 
182
 
            EXPECT_CALL(*result, session_next_buffer_called(testing::_)).
183
 
                Times(1);
184
 
 
185
 
            return result;
 
163
            if (!report)
 
164
            {
 
165
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
166
                EXPECT_CALL(*report, session_next_buffer_called(testing::_)).
 
167
                    Times(1);
 
168
            }
 
169
            return report;
186
170
        }
 
171
        std::shared_ptr<MockSessionMediatorReport> report;
187
172
    } server_processing;
188
 
 
189
173
    launch_server_process(server_processing);
190
174
 
191
175
    struct Client: TestingClientConfiguration
227
211
    launch_client_process(client_process);
228
212
}
229
213
 
230
 
TEST_F(ApplicationMediatorReport, session_release_surface_called)
 
214
TEST_F(SessionMediatorReport, session_exchange_buffer_called)
231
215
{
232
216
    struct Server : TestingServerConfiguration
233
217
    {
234
 
        std::shared_ptr<mf::SessionMediatorReport>
235
 
        the_application_mediator_report()
 
218
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
236
219
        {
237
 
            auto result = std::make_shared<MockApplicationMediatorReport>();
238
 
 
239
 
            EXPECT_CALL(*result, session_release_surface_called(testing::_)).
240
 
                Times(1);
241
 
 
242
 
            return result;
 
220
            if (!report)
 
221
            {
 
222
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
223
                EXPECT_CALL(*report, session_exchange_buffer_called(testing::_)).
 
224
                    Times(1);
 
225
            }
 
226
            return report;
243
227
        }
 
228
        std::shared_ptr<MockSessionMediatorReport> report;
244
229
    } server_processing;
245
 
 
246
230
    launch_server_process(server_processing);
247
231
 
248
232
    struct Client: TestingClientConfiguration
254
238
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
255
239
            EXPECT_CALL(client, connect_done()).Times(testing::AtLeast(0));
256
240
            EXPECT_CALL(client, create_surface_done()).Times(testing::AtLeast(0));
257
 
            EXPECT_CALL(client, next_buffer_done()).Times(testing::AtLeast(0));
258
 
            EXPECT_CALL(client, release_surface_done()).Times(testing::AtLeast(0));
 
241
            EXPECT_CALL(client, exchange_buffer_done()).Times(testing::AtLeast(0));
259
242
 
260
243
            client.display_server.connect(
261
244
                0,
272
255
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::create_surface_done));
273
256
            client.wait_for_create_surface();
274
257
 
 
258
            mir::protobuf::BufferRequest request;
 
259
            *request.mutable_id() =  client.surface.id();
 
260
            *request.mutable_buffer() =  client.surface.buffer();
 
261
 
 
262
            client.display_server.exchange_buffer(
 
263
                0,
 
264
                &request,
 
265
                client.surface.mutable_buffer(),
 
266
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::exchange_buffer_done));
 
267
 
 
268
            client.wait_for_exchange_buffer();
 
269
        }
 
270
    } client_process;
 
271
 
 
272
    launch_client_process(client_process);
 
273
}
 
274
 
 
275
TEST_F(SessionMediatorReport, session_release_surface_called)
 
276
{
 
277
    struct Server : TestingServerConfiguration
 
278
    {
 
279
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
 
280
        {
 
281
            if (!report)
 
282
            {
 
283
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
284
                EXPECT_CALL(*report, session_release_surface_called(testing::_)).
 
285
                    Times(1);
 
286
            }
 
287
            return report;
 
288
        }
 
289
        std::shared_ptr<MockSessionMediatorReport> report;
 
290
    } server_processing;
 
291
    launch_server_process(server_processing);
 
292
 
 
293
    struct Client: TestingClientConfiguration
 
294
    {
 
295
        void exec()
 
296
        {
 
297
            testing::NiceMock<mt::TestProtobufClient> client(mtf::test_socket_file(), rpc_timeout_ms);
 
298
 
 
299
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
 
300
 
 
301
            client.display_server.connect(
 
302
                0,
 
303
                &client.connect_parameters,
 
304
                &client.connection,
 
305
                google::protobuf::NewCallback(
 
306
                    static_cast<mt::TestProtobufClient*>(&client),
 
307
                    &mt::TestProtobufClient::connect_done));
 
308
 
 
309
            client.wait_for_connect_done();
 
310
 
 
311
            client.display_server.create_surface(
 
312
                0,
 
313
                &client.surface_parameters,
 
314
                &client.surface,
 
315
                google::protobuf::NewCallback(
 
316
                    static_cast<mt::TestProtobufClient*>(&client),
 
317
                    &mt::TestProtobufClient::create_surface_done));
 
318
            client.wait_for_create_surface();
 
319
 
275
320
            client.display_server.next_buffer(
276
321
                0,
277
322
                &client.surface.id(),
278
323
                client.surface.mutable_buffer(),
279
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::next_buffer_done));
 
324
                google::protobuf::NewCallback(
 
325
                    static_cast<mt::TestProtobufClient*>(&client),
 
326
                    &mt::TestProtobufClient::next_buffer_done));
280
327
 
281
328
            client.wait_for_next_buffer();
282
329
 
284
331
                0,
285
332
                &client.surface.id(),
286
333
                &client.ignored,
287
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::release_surface_done));
 
334
                google::protobuf::NewCallback(
 
335
                    static_cast<mt::TestProtobufClient*>(&client),
 
336
                    &mt::TestProtobufClient::release_surface_done));
288
337
 
289
338
            client.wait_for_release_surface();
290
339
        }
293
342
    launch_client_process(client_process);
294
343
}
295
344
 
296
 
TEST_F(ApplicationMediatorReport, session_disconnect_called)
 
345
TEST_F(SessionMediatorReport, session_disconnect_called)
297
346
{
298
347
    struct Server : TestingServerConfiguration
299
348
    {
300
 
        std::shared_ptr<mf::SessionMediatorReport>
301
 
        the_application_mediator_report()
 
349
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
302
350
        {
303
 
            auto result = std::make_shared<MockApplicationMediatorReport>();
304
 
 
305
 
            EXPECT_CALL(*result, session_disconnect_called(testing::_)).
306
 
                Times(1);
307
 
 
308
 
            return result;
 
351
            if (!report)
 
352
            {
 
353
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
354
                EXPECT_CALL(*report, session_disconnect_called(testing::_)).
 
355
                    Times(1);
 
356
            }
 
357
            return report;
309
358
        }
 
359
        std::shared_ptr<MockSessionMediatorReport> report;
310
360
    } server_processing;
311
 
 
312
361
    launch_server_process(server_processing);
313
362
 
314
363
    struct Client: TestingClientConfiguration
315
364
    {
316
365
        void exec()
317
366
        {
318
 
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
 
367
            testing::NiceMock<mt::TestProtobufClient> client(mtf::test_socket_file(), rpc_timeout_ms);
319
368
 
320
369
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
321
 
            EXPECT_CALL(client, connect_done()).Times(testing::AtLeast(0));
322
 
            EXPECT_CALL(client, create_surface_done()).Times(testing::AtLeast(0));
323
 
            EXPECT_CALL(client, next_buffer_done()).Times(testing::AtLeast(0));
324
 
            EXPECT_CALL(client, release_surface_done()).Times(testing::AtLeast(0));
325
 
            EXPECT_CALL(client, disconnect_done()).Times(testing::AtLeast(0));
326
370
 
327
371
            client.display_server.connect(
328
372
                0,
329
373
                &client.connect_parameters,
330
374
                &client.connection,
331
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
 
375
                google::protobuf::NewCallback(
 
376
                    static_cast<mt::TestProtobufClient*>(&client),
 
377
                    &mt::TestProtobufClient::connect_done));
332
378
 
333
379
            client.wait_for_connect_done();
334
380
 
336
382
                0,
337
383
                &client.surface_parameters,
338
384
                &client.surface,
339
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::create_surface_done));
 
385
                google::protobuf::NewCallback(
 
386
                    static_cast<mt::TestProtobufClient*>(&client),
 
387
                    &mt::TestProtobufClient::create_surface_done));
340
388
            client.wait_for_create_surface();
341
389
 
342
390
            client.display_server.next_buffer(
343
391
                0,
344
392
                &client.surface.id(),
345
393
                client.surface.mutable_buffer(),
346
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::next_buffer_done));
 
394
                google::protobuf::NewCallback(
 
395
                    static_cast<mt::TestProtobufClient*>(&client),
 
396
                    &mt::TestProtobufClient::next_buffer_done));
347
397
 
348
398
            client.wait_for_next_buffer();
349
399
 
351
401
                0,
352
402
                &client.surface.id(),
353
403
                &client.ignored,
354
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::release_surface_done));
 
404
                google::protobuf::NewCallback(
 
405
                    static_cast<mt::TestProtobufClient*>(&client),
 
406
                    &mt::TestProtobufClient::release_surface_done));
355
407
 
356
408
            client.wait_for_release_surface();
357
409
 
359
411
                0,
360
412
                &client.ignored,
361
413
                &client.ignored,
362
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::disconnect_done));
 
414
                google::protobuf::NewCallback(
 
415
                    static_cast<mt::TestProtobufClient*>(&client),
 
416
                    &mt::TestProtobufClient::disconnect_done));
363
417
 
364
418
            client.wait_for_disconnect_done();
365
419
        }
368
422
    launch_client_process(client_process);
369
423
}
370
424
 
371
 
TEST_F(ApplicationMediatorReport, prompt_session_start_called)
 
425
TEST_F(SessionMediatorReport, prompt_session_start_called)
372
426
{
373
427
    struct Server : TestingServerConfiguration
374
428
    {
375
 
        std::shared_ptr<mf::SessionMediatorReport>
376
 
        the_application_mediator_report()
 
429
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
377
430
        {
378
 
            auto result = std::make_shared<MockApplicationMediatorReport>();
379
 
 
380
 
            EXPECT_CALL(*result, session_start_prompt_session_called(testing::_, testing::_)).
381
 
                Times(1);
382
 
 
383
 
            return result;
 
431
            if (!report)
 
432
            {
 
433
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
434
                EXPECT_CALL(*report, session_start_prompt_session_called(testing::_, testing::_)).
 
435
                    Times(1);
 
436
            }
 
437
            return report;
384
438
        }
 
439
        std::shared_ptr<MockSessionMediatorReport> report;
385
440
    } server_processing;
386
 
 
387
441
    launch_server_process(server_processing);
388
442
 
389
443
    struct Client: TestingClientConfiguration
390
444
    {
391
445
        void exec()
392
446
        {
393
 
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
 
447
            testing::NiceMock<mt::TestProtobufClient> client(mtf::test_socket_file(), rpc_timeout_ms);
394
448
 
395
449
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
396
 
            EXPECT_CALL(client, connect_done()).
397
 
                Times(testing::AtLeast(0));
398
 
            EXPECT_CALL(client, prompt_session_start_done()).
399
 
                Times(testing::AtLeast(0));
400
450
 
401
451
            client.display_server.connect(
402
452
                0,
403
453
                &client.connect_parameters,
404
454
                &client.connection,
405
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
 
455
                google::protobuf::NewCallback(
 
456
                    static_cast<mt::TestProtobufClient*>(&client),
 
457
                    &mt::TestProtobufClient::connect_done));
406
458
 
407
459
            client.wait_for_connect_done();
408
460
 
410
462
                0,
411
463
                &client.prompt_session_parameters,
412
464
                &client.prompt_session,
413
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::prompt_session_start_done));
 
465
                google::protobuf::NewCallback(
 
466
                    static_cast<mt::TestProtobufClient*>(&client),
 
467
                    &mt::TestProtobufClient::prompt_session_start_done));
 
468
 
414
469
            client.wait_for_prompt_session_start_done();
415
470
 
416
471
        }
419
474
    launch_client_process(client_process);
420
475
}
421
476
 
422
 
TEST_F(ApplicationMediatorReport, prompt_session_stop_called)
 
477
TEST_F(SessionMediatorReport, prompt_session_stop_called)
423
478
{
424
479
    struct Server : TestingServerConfiguration
425
480
    {
426
 
        std::shared_ptr<mf::SessionMediatorReport>
427
 
        the_application_mediator_report()
 
481
        std::shared_ptr<mf::SessionMediatorReport> the_session_mediator_report() override
428
482
        {
429
 
            auto result = std::make_shared<MockApplicationMediatorReport>();
430
 
 
431
 
            EXPECT_CALL(*result, session_stop_prompt_session_called(testing::_)).
432
 
                Times(1);
433
 
 
434
 
            return result;
 
483
            if (!report)
 
484
            {
 
485
                report = std::make_shared<testing::NiceMock<MockSessionMediatorReport>>();
 
486
                EXPECT_CALL(*report, session_stop_prompt_session_called(testing::_)).
 
487
                    Times(1);
 
488
            }
 
489
            return report;
435
490
        }
 
491
        std::shared_ptr<MockSessionMediatorReport> report;
436
492
    } server_processing;
437
 
 
438
493
    launch_server_process(server_processing);
439
494
 
440
495
    struct Client: TestingClientConfiguration
441
496
    {
442
497
        void exec()
443
498
        {
444
 
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
 
499
            testing::NiceMock<mt::TestProtobufClient> client(mtf::test_socket_file(), rpc_timeout_ms);
445
500
 
446
501
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
447
 
            EXPECT_CALL(client, connect_done()).
448
 
                Times(testing::AtLeast(0));
449
 
            EXPECT_CALL(client, prompt_session_start_done()).
450
 
                Times(testing::AtLeast(0));
451
 
            EXPECT_CALL(client, prompt_session_stop_done()).
452
 
                Times(testing::AtLeast(0));
453
502
 
454
503
            client.display_server.connect(
455
504
                0,
456
505
                &client.connect_parameters,
457
506
                &client.connection,
458
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
 
507
                google::protobuf::NewCallback(
 
508
                    static_cast<mt::TestProtobufClient*>(&client),
 
509
                    &mt::TestProtobufClient::connect_done));
459
510
 
460
511
            client.wait_for_connect_done();
461
512
 
463
514
                0,
464
515
                &client.prompt_session_parameters,
465
516
                &client.prompt_session,
466
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::prompt_session_start_done));
 
517
                google::protobuf::NewCallback(
 
518
                    static_cast<mt::TestProtobufClient*>(&client),
 
519
                    &mt::TestProtobufClient::prompt_session_start_done));
 
520
 
467
521
            client.wait_for_prompt_session_start_done();
468
522
 
469
523
            client.display_server.stop_prompt_session(
470
524
                0,
471
525
                &client.ignored,
472
526
                &client.ignored,
473
 
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::prompt_session_stop_done));
 
527
                google::protobuf::NewCallback(
 
528
                    static_cast<mt::TestProtobufClient*>(&client),
 
529
                    &mt::TestProtobufClient::prompt_session_stop_done));
 
530
 
474
531
            client.wait_for_prompt_session_stop_done();
475
532
        }
476
533
    } client_process;
477
534
 
478
535
    launch_client_process(client_process);
479
536
}
480
 
 
481