1
=== modified file 'src/client/mir_connection.cpp'
2
--- src/client/mir_connection.cpp	2014-11-03 19:06:48 +0000
3
+++ src/client/mir_connection.cpp	2014-11-05 22:26:46 +0000
4
@@ -34,6 +34,8 @@
5
34
#include <unistd.h>
34
#include <unistd.h>
6
35
#include <signal.h>
35
#include <signal.h>
7
36
36
8
37
#include <boost/exception/diagnostic_information.hpp>
9
38
10
37
namespace mcl = mir::client;
39
namespace mcl = mir::client;
11
38
namespace mircv = mir::input::receiver;
40
namespace mircv = mir::input::receiver;
12
39
namespace gp = google::protobuf;
41
namespace gp = google::protobuf;
13
@@ -219,6 +221,7 @@
14
219
void MirConnection::connected(mir_connected_callback callback, void * context)
221
void MirConnection::connected(mir_connected_callback callback, void * context)
15
220
{
222
{
16
221
    bool safe_to_callback = true;
223
    bool safe_to_callback = true;
17
224
    try
18
222
    {
225
    {
19
223
        std::lock_guard<decltype(mutex)> lock(mutex);
226
        std::lock_guard<decltype(mutex)> lock(mutex);
20
224
227
21
@@ -262,6 +265,11 @@
22
262
        display_configuration->set_configuration(connect_result.display_configuration());
265
        display_configuration->set_configuration(connect_result.display_configuration());
23
263
        lifecycle_control->set_lifecycle_event_handler(default_lifecycle_event_handler);
266
        lifecycle_control->set_lifecycle_event_handler(default_lifecycle_event_handler);
24
264
    }
267
    }
25
268
    catch (std::exception const& e)
26
269
    {
27
270
        connect_result.set_error(std::string{"Failed to process connect response: "} +
28
271
                                 boost::diagnostic_information(e));
29
272
    }
30
265
273
31
266
    if (safe_to_callback) callback(this, context);
274
    if (safe_to_callback) callback(this, context);
32
267
    connect_wait_handle.result_received();
275
    connect_wait_handle.result_received();
33
268
276
34
=== modified file 'src/client/mir_connection_api.cpp'
35
--- src/client/mir_connection_api.cpp	2014-10-01 06:25:56 +0000
36
+++ src/client/mir_connection_api.cpp	2014-11-05 22:26:46 +0000
37
@@ -53,6 +53,7 @@
38
53
{
53
{
39
54
public:
54
public:
40
55
    MirWaitHandle* connect(
55
    MirWaitHandle* connect(
41
56
        mcl::ConfigurationFactory configuration,
42
56
        char const* socket_file,
57
        char const* socket_file,
43
57
        char const* name,
58
        char const* name,
44
58
        mir_connected_callback callback,
59
        mir_connected_callback callback,
45
@@ -112,10 +113,13 @@
46
112
        delete connection;
113
        delete connection;
47
113
    }
114
    }
48
114
115
50
115
    std::unique_ptr<mcl::ConnectionConfiguration> configuration(std::string const& socket) override
116
    mcl::ConfigurationFactory configuration_factory() override
51
116
    {
117
    {
54
117
        return std::unique_ptr<mcl::ConnectionConfiguration>{
118
        return [](std::string const& socket) {
55
118
            new mcl::DefaultConnectionConfiguration{socket}};
119
            return std::unique_ptr<mcl::ConnectionConfiguration>{
56
120
                new mcl::DefaultConnectionConfiguration{socket}
57
121
            };
58
122
        };
59
119
    }
123
    }
60
120
};
124
};
61
121
125
62
@@ -132,7 +136,11 @@
63
132
{
136
{
64
133
    try
137
    try
65
134
    {
138
    {
67
135
        return mir_connection_api_impl->connect(socket_file, name, callback, context);
139
        return mir_connection_api_impl->connect(mir_connection_api_impl->configuration_factory(),
68
140
                                                socket_file,
69
141
                                                name,
70
142
                                                callback,
71
143
                                                context);
72
136
    }
144
    }
73
137
    catch (std::exception const&)
145
    catch (std::exception const&)
74
138
    {
146
    {
75
139
147
76
=== modified file 'src/client/mir_connection_api.h'
77
--- src/client/mir_connection_api.h	2014-10-01 06:25:56 +0000
78
+++ src/client/mir_connection_api.h	2014-11-05 22:26:46 +0000
79
@@ -23,6 +23,7 @@
80
23
23
81
24
#include <string>
24
#include <string>
82
25
#include <memory>
25
#include <memory>
83
26
#include <functional>
84
26
27
85
27
namespace mir
28
namespace mir
86
28
{
29
{
87
@@ -30,12 +31,15 @@
88
30
{
31
{
89
31
class ConnectionConfiguration;
32
class ConnectionConfiguration;
90
32
33
91
34
using ConfigurationFactory = std::function<std::unique_ptr<ConnectionConfiguration>(std::string const&)>;
92
35
93
33
class MirConnectionAPI
36
class MirConnectionAPI
94
34
{
37
{
95
35
public:
38
public:
96
36
    virtual ~MirConnectionAPI() = default;
39
    virtual ~MirConnectionAPI() = default;
97
37
40
98
38
    virtual MirWaitHandle* connect(
41
    virtual MirWaitHandle* connect(
99
42
        ConfigurationFactory configuration,
100
39
        char const* socket_file,
43
        char const* socket_file,
101
40
        char const* name,
44
        char const* name,
102
41
        mir_connected_callback callback,
45
        mir_connected_callback callback,
103
@@ -43,7 +47,7 @@
104
43
47
105
44
    virtual void release(MirConnection* connection) = 0;
48
    virtual void release(MirConnection* connection) = 0;
106
45
49
108
46
    virtual std::unique_ptr<ConnectionConfiguration> configuration(std::string const& socket) = 0;
50
    virtual ConfigurationFactory configuration_factory() = 0;
109
47
51
110
48
protected:
52
protected:
111
49
    MirConnectionAPI() = default;
53
    MirConnectionAPI() = default;
112
50
54
113
=== modified file 'src/client/mir_surface.cpp'
114
--- src/client/mir_surface.cpp	2014-10-28 22:48:39 +0000
115
+++ src/client/mir_surface.cpp	2014-11-05 22:26:46 +0000
116
@@ -30,6 +30,8 @@
117
30
#include <cassert>
30
#include <cassert>
118
31
#include <unistd.h>
31
#include <unistd.h>
119
32
32
120
33
#include <boost/exception/diagnostic_information.hpp>
121
34
122
33
namespace geom = mir::geometry;
35
namespace geom = mir::geometry;
123
34
namespace mcl = mir::client;
36
namespace mcl = mir::client;
124
35
namespace mircv = mir::input::receiver;
37
namespace mircv = mir::input::receiver;
125
@@ -39,11 +41,22 @@
126
39
namespace
41
namespace
127
40
{
42
{
128
41
void null_callback(MirSurface*, void*) {}
43
void null_callback(MirSurface*, void*) {}
129
44
mp::DisplayServer::Stub null_server{nullptr};
130
42
45
131
43
std::mutex handle_mutex;
46
std::mutex handle_mutex;
132
44
std::unordered_set<MirSurface*> valid_surfaces;
47
std::unordered_set<MirSurface*> valid_surfaces;
133
45
}
48
}
134
46
49
135
50
MirSurface::MirSurface(std::string const& error)
136
51
    : server{null_server},
137
52
      connection{nullptr}
138
53
{
139
54
    surface.set_error(error);
140
55
141
56
    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
142
57
    valid_surfaces.insert(this);
143
58
}
144
59
145
47
MirSurface::MirSurface(
60
MirSurface::MirSurface(
146
48
    MirConnection *allocating_connection,
61
    MirConnection *allocating_connection,
147
49
    mp::DisplayServer::Stub & server,
62
    mp::DisplayServer::Stub & server,
148
@@ -258,20 +271,29 @@
149
258
{
271
{
150
259
    auto platform = connection->get_client_platform();
272
    auto platform = connection->get_client_platform();
151
260
273
152
274
    try
153
261
    {
275
    {
154
262
        std::lock_guard<decltype(mutex)> lock(mutex);
155
263
156
264
        process_incoming_buffer();
157
265
        accelerated_window = platform->create_egl_native_window(this);
158
266
        
159
267
        for(int i = 0; i < surface.attributes_size(); i++)
160
268
        {
276
        {
163
269
            auto const& attrib = surface.attributes(i);
277
            std::lock_guard<decltype(mutex)> lock(mutex);
164
270
            attrib_cache[attrib.attrib()] = attrib.ivalue();
278
165
279
            process_incoming_buffer();
166
280
            accelerated_window = platform->create_egl_native_window(this);
167
281
168
282
            for(int i = 0; i < surface.attributes_size(); i++)
169
283
            {
170
284
                auto const& attrib = surface.attributes(i);
171
285
                attrib_cache[attrib.attrib()] = attrib.ivalue();
172
286
            }
173
271
        }
287
        }
177
272
    }
288
178
273
289
        connection->on_surface_created(id(), this);
179
274
    connection->on_surface_created(id(), this);
290
    }
180
291
    catch (std::exception const& error)
181
292
    {
182
293
        surface.set_error(std::string{"Error processing Surface creating response:"} +
183
294
                          boost::diagnostic_information(error));
184
295
    }
185
296
186
275
    callback(this, context);
297
    callback(this, context);
187
276
    create_wait_handle.result_received();
298
    create_wait_handle.result_received();
188
277
}
299
}
189
@@ -296,7 +318,18 @@
190
296
        valid_surfaces.erase(this);
318
        valid_surfaces.erase(this);
191
297
    }
319
    }
192
298
320
194
299
    return connection->release_surface(this, callback, context);
321
    MirWaitHandle* wait_handle{nullptr};
195
322
    if (connection)
196
323
    {
197
324
        wait_handle = connection->release_surface(this, callback, context);
198
325
    }
199
326
    else
200
327
    {
201
328
        callback(this, context);
202
329
        delete this;
203
330
    }
204
331
205
332
    return wait_handle;
206
300
}
333
}
207
301
334
208
302
MirNativeBuffer* MirSurface::get_current_buffer_package()
335
MirNativeBuffer* MirSurface::get_current_buffer_package()
209
303
336
210
=== modified file 'src/client/mir_surface.h'
211
--- src/client/mir_surface.h	2014-10-27 22:31:16 +0000
212
+++ src/client/mir_surface.h	2014-11-05 22:26:46 +0000
213
@@ -59,6 +59,8 @@
214
59
    MirSurface(MirSurface const &) = delete;
59
    MirSurface(MirSurface const &) = delete;
215
60
    MirSurface& operator=(MirSurface const &) = delete;
60
    MirSurface& operator=(MirSurface const &) = delete;
216
61
61
217
62
    MirSurface(std::string const& error);
218
63
219
62
    MirSurface(
64
    MirSurface(
220
63
        MirConnection *allocating_connection,
65
        MirConnection *allocating_connection,
221
64
        mir::protobuf::DisplayServer::Stub & server,
66
        mir::protobuf::DisplayServer::Stub & server,
222
65
67
223
=== modified file 'src/client/mir_surface_api.cpp'
224
--- src/client/mir_surface_api.cpp	2014-10-27 22:31:16 +0000
225
+++ src/client/mir_surface_api.cpp	2014-11-05 22:26:46 +0000
226
@@ -23,6 +23,8 @@
227
23
#include "mir_surface.h"
23
#include "mir_surface.h"
228
24
#include "error_connections.h"
24
#include "error_connections.h"
229
25
25
230
26
#include <boost/exception/diagnostic_information.hpp>
231
27
232
26
namespace mcl = mir::client;
28
namespace mcl = mir::client;
233
27
29
234
28
namespace
30
namespace
235
@@ -43,15 +45,17 @@
236
43
    mir_surface_callback callback,
45
    mir_surface_callback callback,
237
44
    void* context)
46
    void* context)
238
45
{
47
{
240
46
    if (mcl::ErrorConnections::instance().contains(connection)) return 0;
48
    if (!mir_connection_is_valid(connection)) abort();
241
47
49
242
48
    try
50
    try
243
49
    {
51
    {
244
50
        return connection->create_surface(*params, callback, context);
52
        return connection->create_surface(*params, callback, context);
245
51
    }
53
    }
247
52
    catch (std::exception const&)
54
    catch (std::exception const& error)
248
53
    {
55
    {
250
54
        // TODO callback with an error surface
56
        auto error_surf = new MirSurface{std::string{"Failed to create surface: "} +
251
57
                                         boost::diagnostic_information(error)};
252
58
        (*callback)(error_surf, context);
253
55
        return nullptr;
59
        return nullptr;
254
56
    }
60
    }
255
57
}
61
}
256
58
62
257
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
258
--- tests/acceptance-tests/CMakeLists.txt	2014-11-03 19:06:48 +0000
259
+++ tests/acceptance-tests/CMakeLists.txt	2014-11-05 22:26:46 +0000
260
@@ -17,6 +17,7 @@
261
17
  server_signal_handling.cpp
17
  server_signal_handling.cpp
262
18
  clients.cpp
18
  clients.cpp
263
19
  test_client_library.cpp
19
  test_client_library.cpp
264
20
  test_client_library_errors.cpp
265
20
  test_client_library_old.cpp
21
  test_client_library_old.cpp
266
21
  test_client_surface_events.cpp
22
  test_client_surface_events.cpp
267
22
  test_client_surface_swap_buffers.cpp
23
  test_client_surface_swap_buffers.cpp
268
23
24
269
=== modified file 'tests/acceptance-tests/test_client_library.cpp'
270
--- tests/acceptance-tests/test_client_library.cpp	2014-10-29 10:11:50 +0000
271
+++ tests/acceptance-tests/test_client_library.cpp	2014-11-05 22:26:46 +0000
272
@@ -53,8 +53,6 @@
273
53
{
53
{
274
54
struct ClientLibrary : mtf::HeadlessInProcessServer
54
struct ClientLibrary : mtf::HeadlessInProcessServer
275
55
{
55
{
276
56
    mtf::UsingStubClientPlatform using_stub_client_platform;
277
57
278
58
    std::set<MirSurface*> surfaces;
56
    std::set<MirSurface*> surfaces;
279
59
    MirConnection* connection = nullptr;
57
    MirConnection* connection = nullptr;
280
60
    MirSurface* surface  = nullptr;
58
    MirSurface* surface  = nullptr;
281
@@ -597,42 +595,6 @@
282
597
    mir_connection_release(connection);
595
    mir_connection_release(connection);
283
598
}
596
}
284
599
597
285
600
TEST_F(ClientLibrary, connect_errors_handled)
286
601
{
287
602
    mir_wait_for(mir_connect("garbage", __PRETTY_FUNCTION__, connection_callback, this));
288
603
    ASSERT_THAT(connection, NotNull());
289
604
290
605
    char const* error = mir_connection_get_error_message(connection);
291
606
292
607
    if (std::strcmp("connect: No such file or directory", error) &&
293
608
        std::strcmp("Can't find MIR server", error) &&
294
609
        !std::strstr(error, "Failed to connect to server socket"))
295
610
    {
296
611
        FAIL() << error;
297
612
    }
298
613
}
299
614
300
615
TEST_F(ClientLibrary, connect_errors_dont_blow_up)
301
616
{
302
617
    mir_wait_for(mir_connect("garbage", __PRETTY_FUNCTION__, connection_callback, this));
303
618
304
619
    MirSurfaceParameters const request_params =
305
620
    {
306
621
        __PRETTY_FUNCTION__,
307
622
        640, 480,
308
623
        mir_pixel_format_abgr_8888,
309
624
        mir_buffer_usage_hardware,
310
625
        mir_display_output_id_invalid
311
626
    };
312
627
313
628
    mir_wait_for(mir_connection_create_surface(connection, &request_params, create_surface_callback, this));
314
629
// TODO surface_create needs to fail safe too. After that is done we should add the following:
315
630
// TODO    mir_wait_for(mir_surface_swap_buffers(surface, next_buffer_callback, this));
316
631
// TODO    mir_wait_for(mir_surface_release( surface, release_surface_callback, this));
317
632
318
633
    mir_connection_release(connection);
319
634
}
320
635
321
636
TEST_F(ClientLibrary, MultiSurfaceClientTracksBufferFdsCorrectly)
598
TEST_F(ClientLibrary, MultiSurfaceClientTracksBufferFdsCorrectly)
322
637
{
599
{
323
638
    mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
600
    mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
324
639
601
325
=== added file 'tests/acceptance-tests/test_client_library_errors.cpp'
326
--- tests/acceptance-tests/test_client_library_errors.cpp	1970-01-01 00:00:00 +0000
327
+++ tests/acceptance-tests/test_client_library_errors.cpp	2014-11-05 22:26:46 +0000
328
@@ -0,0 +1,338 @@
329
1
/*
330
2
 * Copyright © 2014 Canonical Ltd.
331
3
 *
332
4
 * This program is free software: you can redistribute it and/or modify
333
5
 * it under the terms of the GNU General Public License version 3 as
334
6
 * published by the Free Software Foundation.
335
7
 *
336
8
 * This program is distributed in the hope that it will be useful,
337
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
338
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
339
11
 * GNU General Public License for more details.
340
12
 *
341
13
 * You should have received a copy of the GNU General Public License
342
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
343
15
 *
344
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
345
17
 */
346
18
347
19
#include "mir_toolkit/mir_client_library.h"
348
20
#include "mir_toolkit/debug/surface.h"
349
21
350
22
#include "src/client/client_platform_factory.h"
351
23
#include "src/client/client_platform.h"
352
24
#include "src/client/client_buffer_factory.h"
353
25
354
26
#include "mir_test/validity_matchers.h"
355
27
356
28
#include "mir_test_framework/in_process_server.h"
357
29
#include "mir_test_framework/stubbed_server_configuration.h"
358
30
#include "mir_test_framework/using_stub_client_platform.h"
359
31
#include "mir_test_framework/stub_client_connection_configuration.h"
360
32
361
33
#include <gtest/gtest.h>
362
34
#include <gmock/gmock.h>
363
35
364
36
#include <stdexcept>
365
37
#include <boost/throw_exception.hpp>
366
38
#include <cstring>
367
39
368
40
namespace mcl = mir::client;
369
41
namespace mtf = mir_test_framework;
370
42
371
43
namespace
372
44
{
373
45
enum Method : uint64_t
374
46
{
375
47
    none = 0,
376
48
    the_client_platform_factory = 1<<0,
377
49
    create_client_platform      = 1<<1,
378
50
    create_egl_native_window    = 1<<2,
379
51
    create_buffer_factory       = 1<<3
380
52
};
381
53
382
54
std::string const exception_text{"Ducks!"};
383
55
384
56
template<Method name, Method failure_set>
385
57
bool should_fail()
386
58
{
387
59
    return (name & failure_set);
388
60
}
389
61
390
62
class StubClientBufferFactory : public mir::client::ClientBufferFactory
391
63
{
392
64
    std::shared_ptr<mir::client::ClientBuffer> create_buffer(const std::shared_ptr<MirBufferPackage>&,
393
65
                                                             mir::geometry::Size,
394
66
                                                             MirPixelFormat)
395
67
    {
396
68
        return std::shared_ptr<mir::client::ClientBuffer>{};
397
69
    }
398
70
};
399
71
400
72
template<Method failure_set>
401
73
class ConfigurableFailurePlatform : public mir::client::ClientPlatform
402
74
{
403
75
    std::shared_ptr<EGLNativeWindowType> create_egl_native_window(mir::client::ClientSurface *)
404
76
    {
405
77
        if (should_fail<Method::create_egl_native_window, failure_set>())
406
78
        {
407
79
            BOOST_THROW_EXCEPTION(std::runtime_error{exception_text});
408
80
        }
409
81
        return std::shared_ptr<EGLNativeWindowType>{};
410
82
    }
411
83
    MirPlatformType platform_type() const
412
84
    {
413
85
        BOOST_THROW_EXCEPTION(std::runtime_error{exception_text});
414
86
        return MirPlatformType::mir_platform_type_gbm;
415
87
    }
416
88
    std::shared_ptr<mir::client::ClientBufferFactory> create_buffer_factory()
417
89
    {
418
90
        if (should_fail<Method::create_buffer_factory, failure_set>())
419
91
        {
420
92
            BOOST_THROW_EXCEPTION(std::runtime_error{exception_text});
421
93
        }
422
94
        return std::make_shared<StubClientBufferFactory>();
423
95
    }
424
96
    std::shared_ptr<EGLNativeDisplayType> create_egl_native_display()
425
97
    {
426
98
        return std::shared_ptr<EGLNativeDisplayType>{};
427
99
    }
428
100
    MirNativeBuffer *convert_native_buffer(mir::graphics::NativeBuffer*) const
429
101
    {
430
102
        BOOST_THROW_EXCEPTION(std::runtime_error{exception_text});
431
103
        return nullptr;
432
104
    }
433
105
};
434
106
435
107
template<Method failure_set>
436
108
class ConfigurableFailureFactory: public mir::client::ClientPlatformFactory
437
109
{
438
110
    std::shared_ptr<mir::client::ClientPlatform>
439
111
    create_client_platform(mir::client::ClientContext* /*context*/) override
440
112
    {
441
113
        if (should_fail<Method::create_client_platform, failure_set>())
442
114
        {
443
115
            BOOST_THROW_EXCEPTION(std::runtime_error{exception_text});
444
116
        }
445
117
        return std::make_shared<ConfigurableFailurePlatform<failure_set>>();
446
118
    }
447
119
};
448
120
449
121
template<Method failure_set>
450
122
class ConfigurableFailureConfiguration : public mtf::StubConnectionConfiguration
451
123
{
452
124
    using mtf::StubConnectionConfiguration::StubConnectionConfiguration;
453
125
454
126
    std::shared_ptr<mir::client::ClientPlatformFactory> the_client_platform_factory() override
455
127
    {
456
128
        if (should_fail<Method::the_client_platform_factory, failure_set>())
457
129
        {
458
130
            BOOST_THROW_EXCEPTION(std::runtime_error{exception_text});
459
131
        }
460
132
        return std::make_shared<ConfigurableFailureFactory<failure_set>>();
461
133
    }
462
134
};
463
135
464
136
class ClientLibraryErrors : public mtf::InProcessServer
465
137
{
466
138
private:
467
139
    mtf::StubbedServerConfiguration config;
468
140
469
141
    mir::DefaultServerConfiguration &server_config() override
470
142
    {
471
143
        return config;
472
144
    }
473
145
};
474
146
}
475
147
476
148
TEST_F(ClientLibraryErrors, exception_in_client_configuration_constructor_generates_error)
477
149
{
478
150
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::the_client_platform_factory>> stubby;
479
151
480
152
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
481
153
482
154
    EXPECT_FALSE(mir_connection_is_valid(connection));
483
155
    EXPECT_THAT(mir_connection_get_error_message(connection), testing::HasSubstr(exception_text));
484
156
    mir_connection_release(connection);
485
157
}
486
158
487
159
TEST_F(ClientLibraryErrors, exception_in_platform_construction_generates_error)
488
160
{
489
161
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::create_client_platform>> stubby;
490
162
491
163
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
492
164
493
165
    EXPECT_FALSE(mir_connection_is_valid(connection));
494
166
    EXPECT_THAT(mir_connection_get_error_message(connection), testing::HasSubstr(exception_text));
495
167
    mir_connection_release(connection);
496
168
}
497
169
498
170
TEST_F(ClientLibraryErrors, connecting_to_garbage_socket_returns_appropriate_error)
499
171
{
500
172
    using namespace testing;
501
173
    mtf::UsingStubClientPlatform stubby;
502
174
503
175
    auto connection = mir_connect_sync("garbage", __PRETTY_FUNCTION__);
504
176
    ASSERT_THAT(connection, NotNull());
505
177
506
178
    char const* error = mir_connection_get_error_message(connection);
507
179
508
180
    if (std::strcmp("connect: No such file or directory", error) &&
509
181
        std::strcmp("Can't find MIR server", error) &&
510
182
        !std::strstr(error, "Failed to connect to server socket"))
511
183
    {
512
184
        FAIL() << error;
513
185
    }
514
186
    mir_connection_release(connection);
515
187
}
516
188
517
189
TEST_F(ClientLibraryErrors, create_surface_returns_error_object_on_failure)
518
190
{
519
191
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::create_buffer_factory>> stubby;
520
192
521
193
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
522
194
523
195
    ASSERT_THAT(connection, IsValid());
524
196
525
197
    MirSurfaceParameters const request_params =
526
198
    {
527
199
        __PRETTY_FUNCTION__,
528
200
        640, 480,
529
201
        mir_pixel_format_abgr_8888,
530
202
        mir_buffer_usage_hardware,
531
203
        mir_display_output_id_invalid
532
204
    };
533
205
534
206
    auto surface = mir_connection_create_surface_sync(connection, &request_params);
535
207
    ASSERT_NE(surface, nullptr);
536
208
    EXPECT_FALSE(mir_surface_is_valid(surface));
537
209
    EXPECT_THAT(mir_surface_get_error_message(surface), testing::HasSubstr(exception_text));
538
210
539
211
    mir_surface_release_sync(surface);
540
212
    mir_connection_release(connection);
541
213
}
542
214
543
215
namespace
544
216
{
545
217
void recording_surface_callback(MirSurface*, void* ctx)
546
218
{
547
219
    auto called = static_cast<bool*>(ctx);
548
220
    *called = true;
549
221
}
550
222
}
551
223
552
224
TEST_F(ClientLibraryErrors, surface_release_on_error_object_still_calls_callback)
553
225
{
554
226
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::create_buffer_factory>> stubby;
555
227
556
228
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
557
229
558
230
    ASSERT_THAT(connection, IsValid());
559
231
560
232
    MirSurfaceParameters const request_params =
561
233
    {
562
234
        __PRETTY_FUNCTION__,
563
235
        640, 480,
564
236
        mir_pixel_format_abgr_8888,
565
237
        mir_buffer_usage_hardware,
566
238
        mir_display_output_id_invalid
567
239
    };
568
240
569
241
    auto surface = mir_connection_create_surface_sync(connection, &request_params);
570
242
    ASSERT_NE(surface, nullptr);
571
243
    EXPECT_FALSE(mir_surface_is_valid(surface));
572
244
    EXPECT_THAT(mir_surface_get_error_message(surface), testing::HasSubstr(exception_text));
573
245
574
246
    bool callback_called{false};
575
247
    mir_surface_release(surface, &recording_surface_callback, &callback_called);
576
248
    EXPECT_TRUE(callback_called);
577
249
    mir_connection_release(connection);
578
250
}
579
251
580
252
581
253
TEST_F(ClientLibraryErrors, create_surface_returns_error_object_on_failure_in_reply_processing)
582
254
{
583
255
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::create_egl_native_window>> stubby;
584
256
585
257
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
586
258
587
259
    ASSERT_THAT(connection, IsValid());
588
260
589
261
    MirSurfaceParameters const request_params =
590
262
    {
591
263
        __PRETTY_FUNCTION__,
592
264
        640, 480,
593
265
        mir_pixel_format_abgr_8888,
594
266
        mir_buffer_usage_hardware,
595
267
        mir_display_output_id_invalid
596
268
    };
597
269
598
270
    auto surface = mir_connection_create_surface_sync(connection, &request_params);
599
271
    ASSERT_NE(surface, nullptr);
600
272
    EXPECT_FALSE(mir_surface_is_valid(surface));
601
273
    EXPECT_THAT(mir_surface_get_error_message(surface), testing::HasSubstr(exception_text));
602
274
603
275
    mir_surface_release_sync(surface);
604
276
    mir_connection_release(connection);
605
277
}
606
278
607
279
using ClientLibraryErrorsDeathTest = ClientLibraryErrors;
608
280
609
281
610
282
TEST_F(ClientLibraryErrorsDeathTest, createing_surface_on_garbage_connection_is_fatal)
611
283
{
612
284
    mtf::UsingStubClientPlatform stubby;
613
285
614
286
    auto connection = mir_connect_sync("garbage", __PRETTY_FUNCTION__);
615
287
616
288
    MirSurfaceParameters const request_params =
617
289
    {
618
290
        __PRETTY_FUNCTION__,
619
291
        640, 480,
620
292
        mir_pixel_format_abgr_8888,
621
293
        mir_buffer_usage_hardware,
622
294
        mir_display_output_id_invalid
623
295
    };
624
296
625
297
    ASSERT_FALSE(mir_connection_is_valid(connection));
626
298
    EXPECT_DEATH(mir_connection_create_surface_sync(connection, &request_params), "");
627
299
}
628
300
629
301
630
302
TEST_F(ClientLibraryErrorsDeathTest, creating_surface_synchronosly_on_malconstructed_connection_is_fatal)
631
303
{
632
304
    MirSurfaceParameters const request_params =
633
305
    {
634
306
        __PRETTY_FUNCTION__,
635
307
        640, 480,
636
308
        mir_pixel_format_abgr_8888,
637
309
        mir_buffer_usage_hardware,
638
310
        mir_display_output_id_invalid
639
311
    };
640
312
641
313
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::the_client_platform_factory>> stubby;
642
314
643
315
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
644
316
645
317
    ASSERT_FALSE(mir_connection_is_valid(connection));
646
318
    EXPECT_DEATH(mir_connection_create_surface_sync(connection, &request_params), "");
647
319
}
648
320
649
321
TEST_F(ClientLibraryErrorsDeathTest, creating_surface_synchronosly_on_invalid_connection_is_fatal)
650
322
{
651
323
    MirSurfaceParameters const request_params =
652
324
    {
653
325
        __PRETTY_FUNCTION__,
654
326
        640, 480,
655
327
        mir_pixel_format_abgr_8888,
656
328
        mir_buffer_usage_hardware,
657
329
        mir_display_output_id_invalid
658
330
    };
659
331
660
332
    mtf::UsingClientPlatform<ConfigurableFailureConfiguration<Method::create_client_platform>> stubby;
661
333
662
334
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
663
335
664
336
    ASSERT_FALSE(mir_connection_is_valid(connection));
665
337
    EXPECT_DEATH(mir_connection_create_surface_sync(connection, &request_params), "");
666
338
}
667
0
339
668
=== modified file 'tests/acceptance-tests/test_server_disconnect.cpp'
669
--- tests/acceptance-tests/test_server_disconnect.cpp	2014-10-01 06:25:56 +0000
670
+++ tests/acceptance-tests/test_server_disconnect.cpp	2014-11-05 22:26:46 +0000
671
@@ -107,7 +107,7 @@
672
107
                mir_buffer_usage_hardware,
107
                mir_buffer_usage_hardware,
673
108
                mir_display_output_id_invalid
108
                mir_display_output_id_invalid
674
109
            };
109
            };
676
110
            mir_connection_create_surface_sync(connection, &parameters);
110
            surf = mir_connection_create_surface_sync(connection, &parameters);
677
111
        });
111
        });
678
112
112
679
113
        configure_display.exec([&] {
113
        configure_display.exec([&] {
680
@@ -117,6 +117,7 @@
681
117
        });
117
        });
682
118
118
683
119
        disconnect.exec([&] {
119
        disconnect.exec([&] {
684
120
            mir_surface_release_sync(surf);
685
120
            mir_connection_release(connection);
121
            mir_connection_release(connection);
686
121
        });
122
        });
687
122
    }
123
    }
688
@@ -129,6 +130,8 @@
689
129
    mt::CrossProcessAction create_surface;
130
    mt::CrossProcessAction create_surface;
690
130
    mt::CrossProcessAction configure_display;
131
    mt::CrossProcessAction configure_display;
691
131
    mt::CrossProcessAction disconnect;
132
    mt::CrossProcessAction disconnect;
692
133
private:
693
134
    MirSurface* surf;
694
132
};
135
};
695
133
136
696
134
/*
137
/*
697
135
138
698
=== modified file 'tests/include/mir_test/stub_server_tool.h'
699
--- tests/include/mir_test/stub_server_tool.h	2014-10-01 06:25:56 +0000
700
+++ tests/include/mir_test/stub_server_tool.h	2014-11-05 22:26:46 +0000
701
@@ -86,7 +86,14 @@
702
86
                         ::google::protobuf::Closure* done) override
86
                         ::google::protobuf::Closure* done) override
703
87
    {
87
    {
704
88
        app_name = request->application_name();
88
        app_name = request->application_name();
706
89
        connect_msg->set_error("");
89
        // If you check out MirConnection::connected either the platform and display_configuration
707
90
        // have to be set or the error has to be set, otherwise we die and fail to callback.
708
91
        //
709
92
        // Since setting the error to "" means that mir_connection_is_valid will return false
710
93
        // with a confusing non-error-message, instead clear the error and set the platform et al.
711
94
        connect_msg->clear_error();
712
95
        connect_msg->set_allocated_platform(new mir::protobuf::Platform{});
713
96
        connect_msg->set_allocated_display_configuration(new mir::protobuf::DisplayConfiguration{});
714
90
        done->Run();
97
        done->Run();
715
91
    }
98
    }
716
92
99
717
93
100
718
=== added file 'tests/include/mir_test/validity_matchers.h'
719
--- tests/include/mir_test/validity_matchers.h	1970-01-01 00:00:00 +0000
720
+++ tests/include/mir_test/validity_matchers.h	2014-11-05 22:26:46 +0000
721
@@ -0,0 +1,64 @@
722
1
/*
723
2
 * Copyright © 2014 Canonical Ltd.
724
3
 *
725
4
 * This program is free software: you can redistribute it and/or modify it
726
5
 * under the terms of the GNU General Public License version 3,
727
6
 * as published by the Free Software Foundation.
728
7
 *
729
8
 * This program is distributed in the hope that it will be useful,
730
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
731
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
732
11
 * GNU General Public License for more details.
733
12
 *
734
13
 * You should have received a copy of the GNU General Public License
735
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
736
15
 *
737
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
738
17
 */
739
18
740
19
#ifndef MIR_TEST_VALIDITY_MATCHERS_H_
741
20
#define MIR_TEST_VALIDITY_MATCHERS_H_
742
21
743
22
#include <gmock/gmock.h>
744
23
745
24
#include "mir_toolkit/mir_client_library.h"
746
25
747
26
using ::testing::MakePolymorphicMatcher;
748
27
using ::testing::MatchResultListener;
749
28
using ::testing::NotNull;
750
29
using ::testing::PolymorphicMatcher;
751
30
752
31
class IsValidMatcher {
753
32
public:
754
33
    // To implement a polymorphic matcher, first define a COPYABLE class
755
34
    // that has three members MatchAndExplain(), DescribeTo(), and
756
35
    // DescribeNegationTo(), like the following.
757
36
758
37
    // In this example, we want to use NotNull() with any pointer, so
759
38
    // MatchAndExplain() accepts a pointer of any type as its first argument.
760
39
    // In general, you can define MatchAndExplain() as an ordinary method or
761
40
    // a method template, or even overload it.
762
41
    template <typename T>
763
42
    bool MatchAndExplain(T* p, MatchResultListener* listener) const;
764
43
765
44
    // Describes the property of a value matching this matcher.
766
45
    void DescribeTo(::std::ostream* os) const { *os << "is valid"; }
767
46
768
47
    // Describes the property of a value NOT matching this matcher.
769
48
    void DescribeNegationTo(::std::ostream* os) const { *os << "is not valid"; }
770
49
};
771
50
772
51
template<>
773
52
bool IsValidMatcher::MatchAndExplain(MirConnection* connection, MatchResultListener* listener) const;
774
53
775
54
template<>
776
55
bool IsValidMatcher::MatchAndExplain(MirSurface* surface, MatchResultListener* listener) const;
777
56
778
57
// To construct a polymorphic matcher, pass an instance of the class
779
58
// to MakePolymorphicMatcher().  Note the return type.
780
59
inline PolymorphicMatcher<IsValidMatcher> IsValid()
781
60
{
782
61
    return MakePolymorphicMatcher(IsValidMatcher{});
783
62
}
784
63
785
64
#endif // MIR_TEST_VALIDITY_MATCHERS_H_
786
0
65
787
=== modified file 'tests/include/mir_test_framework/using_stub_client_platform.h'
788
--- tests/include/mir_test_framework/using_stub_client_platform.h	2014-10-01 06:25:56 +0000
789
+++ tests/include/mir_test_framework/using_stub_client_platform.h	2014-11-05 22:26:46 +0000
790
@@ -20,32 +20,76 @@
791
20
#define MIR_TEST_FRAMEWORK_USING_STUB_CLIENT_PLATFORM_H_
20
#define MIR_TEST_FRAMEWORK_USING_STUB_CLIENT_PLATFORM_H_
792
21
21
793
22
#include <memory>
22
#include <memory>
802
23
23
#include <functional>
803
24
namespace mir
24
804
25
{
25
#include "mir_test_framework/stub_client_connection_configuration.h"
805
26
namespace client
26
#include "src/client/mir_connection_api.h"
806
27
{
27
807
28
class MirConnectionAPI;
28
namespace mcl = mir::client;
800
29
}
801
30
}
808
31
29
809
32
namespace mir_test_framework
30
namespace mir_test_framework
810
33
{
31
{
811
34
32
821
35
class UsingStubClientPlatform
33
class StubMirConnectionAPI : public mcl::MirConnectionAPI
822
36
{
34
{
823
37
public:
35
public:
824
38
    UsingStubClientPlatform();
36
    StubMirConnectionAPI(mcl::MirConnectionAPI* prev_api,
825
39
    ~UsingStubClientPlatform();
37
                         mcl::ConfigurationFactory factory)
826
40
38
        : prev_api{prev_api},
827
41
private:
39
          factory{factory}
828
42
    UsingStubClientPlatform(UsingStubClientPlatform const&) = delete;
40
    {
829
43
    UsingStubClientPlatform operator=(UsingStubClientPlatform const&) = delete;
41
    }
830
42
831
43
    MirWaitHandle* connect(
832
44
        mcl::ConfigurationFactory configuration,
833
45
        char const* socket_file,
834
46
        char const* name,
835
47
        mir_connected_callback callback,
836
48
        void* context) override;
837
49
838
50
    void release(MirConnection* connection) override;
839
51
840
52
    mcl::ConfigurationFactory configuration_factory() override;
841
53
842
54
private:
843
55
    mcl::MirConnectionAPI* const prev_api;
844
56
    mcl::ConfigurationFactory factory;
845
57
};
846
58
847
59
template<class ClientConfig>
848
60
class UsingClientPlatform
849
61
{
850
62
public:
851
63
    UsingClientPlatform()
852
64
        : prev_api{mir_connection_api_impl},
853
65
          stub_api{new StubMirConnectionAPI{prev_api, make_configuration_factory()}}
854
66
    {
855
67
        mir_connection_api_impl = stub_api.get();
856
68
    }
857
69
858
70
    ~UsingClientPlatform()
859
71
    {
860
72
        mir_connection_api_impl = prev_api;
861
73
    }
862
74
863
75
private:
864
76
    UsingClientPlatform(UsingClientPlatform const&) = delete;
865
77
    UsingClientPlatform operator=(UsingClientPlatform const&) = delete;
866
44
78
867
45
    mir::client::MirConnectionAPI* prev_api;
79
    mir::client::MirConnectionAPI* prev_api;
868
46
    std::unique_ptr<mir::client::MirConnectionAPI> stub_api;
80
    std::unique_ptr<mir::client::MirConnectionAPI> stub_api;
869
81
870
82
    mcl::ConfigurationFactory make_configuration_factory()
871
83
    {
872
84
        return [](std::string const& socket) {
873
85
            return std::unique_ptr<mir::client::ConnectionConfiguration>{
874
86
                new ClientConfig{socket}
875
87
            };
876
88
        };
877
89
    }
878
47
};
90
};
879
48
91
880
92
using UsingStubClientPlatform = UsingClientPlatform<StubConnectionConfiguration>;
881
49
}
93
}
882
50
94
883
51
#endif /* MIR_TEST_FRAMEWORK_USING_STUB_CLIENT_PLATFORM_H_ */
95
#endif /* MIR_TEST_FRAMEWORK_USING_STUB_CLIENT_PLATFORM_H_ */
884
52
96
885
=== modified file 'tests/integration-tests/client/test_client_render.cpp'
886
--- tests/integration-tests/client/test_client_render.cpp	2014-10-30 18:37:11 +0000
887
+++ tests/integration-tests/client/test_client_render.cpp	2014-11-05 22:26:46 +0000
888
@@ -28,6 +28,7 @@
889
28
#include "examples/testdraw/patterns.h"
28
#include "examples/testdraw/patterns.h"
890
29
#include "mir_test/stub_server_tool.h"
29
#include "mir_test/stub_server_tool.h"
891
30
#include "mir_test/test_protobuf_server.h"
30
#include "mir_test/test_protobuf_server.h"
892
31
#include "mir_test/validity_matchers.h"
893
31
32
894
32
#include "mir/frontend/connector.h"
33
#include "mir/frontend/connector.h"
895
33
34
896
@@ -92,7 +93,9 @@
897
92
            mir_buffer_usage_software, mir_display_output_id_invalid
93
            mir_buffer_usage_software, mir_display_output_id_invalid
898
93
        };
94
        };
899
94
        auto connection = mir_connect_sync(socket_file, "test_renderer");
95
        auto connection = mir_connect_sync(socket_file, "test_renderer");
900
96
        EXPECT_THAT(connection, IsValid());
901
95
        auto surface = mir_connection_create_surface_sync(connection, &surface_parameters);
97
        auto surface = mir_connection_create_surface_sync(connection, &surface_parameters);
902
98
        EXPECT_THAT(surface, IsValid());
903
96
        MirGraphicsRegion graphics_region;
99
        MirGraphicsRegion graphics_region;
904
97
        for(int i=0u; i < num_frames; i++)
100
        for(int i=0u; i < num_frames; i++)
905
98
        {
101
        {
906
@@ -119,6 +122,7 @@
907
119
        process_sync.wait_for_signal_ready_for();
122
        process_sync.wait_for_signal_ready_for();
908
120
123
909
121
        auto connection = mir_connect_sync(socket_file, "test_renderer");
124
        auto connection = mir_connect_sync(socket_file, "test_renderer");
910
125
        EXPECT_THAT(connection, IsValid());
911
122
126
912
123
        /* set up egl context */
127
        /* set up egl context */
913
124
        int major, minor, n;
128
        int major, minor, n;
914
@@ -137,7 +141,9 @@
915
137
        eglInitialize(egl_display, &major, &minor);
141
        eglInitialize(egl_display, &major, &minor);
916
138
        eglChooseConfig(egl_display, attribs, &egl_config, 1, &n);
142
        eglChooseConfig(egl_display, attribs, &egl_config, 1, &n);
917
139
143
919
140
        auto mir_surface = create_mir_surface(connection, egl_display, egl_config);
144
        auto mir_surface = create_mir_surface(connection, egl_display, egl_config);        
920
145
        EXPECT_THAT(mir_surface, IsValid());
921
146
922
141
        auto native_window = static_cast<EGLNativeWindowType>(
147
        auto native_window = static_cast<EGLNativeWindowType>(
923
142
            mir_surface_get_egl_native_window(mir_surface));
148
            mir_surface_get_egl_native_window(mir_surface));
924
143
149
925
144
150
926
=== modified file 'tests/integration-tests/test_error_reporting.cpp'
927
--- tests/integration-tests/test_error_reporting.cpp	2014-10-01 06:25:56 +0000
928
+++ tests/integration-tests/test_error_reporting.cpp	2014-11-05 22:26:46 +0000
929
@@ -24,6 +24,7 @@
930
24
#include "mir/frontend/connector.h"
24
#include "mir/frontend/connector.h"
931
25
25
932
26
#include "src/server/frontend/display_server.h"
26
#include "src/server/frontend/display_server.h"
933
27
#include "src/server/scene/surface_allocator.h"
934
27
28
935
28
#include "mir_test_framework/display_server_test_fixture.h"
29
#include "mir_test_framework/display_server_test_fixture.h"
936
29
#include "mir_test_doubles/stub_ipc_factory.h"
30
#include "mir_test_doubles/stub_ipc_factory.h"
937
@@ -34,6 +35,7 @@
938
34
#include <gmock/gmock.h>
35
#include <gmock/gmock.h>
939
35
#include <gtest/gtest.h>
36
#include <gtest/gtest.h>
940
36
#include "mir_test/gmock_fixes.h"
37
#include "mir_test/gmock_fixes.h"
941
38
#include "mir_test/validity_matchers.h"
942
37
39
943
38
namespace mc = mir::compositor;
40
namespace mc = mir::compositor;
944
39
namespace mf = mir::frontend;
41
namespace mf = mir::frontend;
945
@@ -45,32 +47,13 @@
946
45
namespace
47
namespace
947
46
{
48
{
948
47
char const* const mir_test_socket = mtf::test_socket_file().c_str();
49
char const* const mir_test_socket = mtf::test_socket_file().c_str();
951
48
50
std::string const test_exception_text{"test exception text"};
952
49
struct ErrorServer : mf::detail::DisplayServer
51
953
52
954
53
struct ConnectionErrorServer : mf::detail::DisplayServer
955
50
{
54
{
956
51
    void client_pid(int /*pid*/) override {}
55
    void client_pid(int /*pid*/) override {}
957
52
56
958
53
    static std::string const test_exception_text;
959
54
960
55
    void create_surface(
961
56
        google::protobuf::RpcController*,
962
57
        const mir::protobuf::SurfaceParameters*,
963
58
        mir::protobuf::Surface*,
964
59
        google::protobuf::Closure*)
965
60
    {
966
61
        throw std::runtime_error(test_exception_text);
967
62
    }
968
63
969
64
    void release_surface(
970
65
        google::protobuf::RpcController*,
971
66
        const mir::protobuf::SurfaceId*,
972
67
        mir::protobuf::Void*,
973
68
        google::protobuf::Closure*)
974
69
    {
975
70
        throw std::runtime_error(test_exception_text);
976
71
    }
977
72
978
73
979
74
    void connect(
57
    void connect(
980
75
        ::google::protobuf::RpcController*,
58
        ::google::protobuf::RpcController*,
981
76
        const ::mir::protobuf::ConnectParameters*,
59
        const ::mir::protobuf::ConnectParameters*,
982
@@ -90,8 +73,6 @@
983
90
    }
73
    }
984
91
};
74
};
985
92
75
986
93
std::string const ErrorServer::test_exception_text{"test exception text"};
987
94
988
95
struct SurfaceSync
76
struct SurfaceSync
989
96
{
77
{
990
97
    SurfaceSync() :
78
    SurfaceSync() :
991
@@ -193,7 +174,7 @@
992
193
174
993
194
using ErrorReporting = BespokeDisplayServerTestFixture;
175
using ErrorReporting = BespokeDisplayServerTestFixture;
994
195
176
996
196
TEST_F(ErrorReporting, c_api_returns_error)
177
TEST_F(ErrorReporting, c_api_returns_connection_error)
997
197
{
178
{
998
198
179
999
199
    struct ServerConfig : TestingServerConfiguration
180
    struct ServerConfig : TestingServerConfiguration
1000
@@ -201,7 +182,7 @@
1001
201
        std::shared_ptr<mf::ProtobufIpcFactory> new_ipc_factory(
182
        std::shared_ptr<mf::ProtobufIpcFactory> new_ipc_factory(
1002
202
            std::shared_ptr<mf::SessionAuthorizer> const&) override
183
            std::shared_ptr<mf::SessionAuthorizer> const&) override
1003
203
        {
184
        {
1005
204
            static auto error_server = std::make_shared<ErrorServer>();
185
            static auto error_server = std::make_shared<ConnectionErrorServer>();
1006
205
            return std::make_shared<mtd::StubIpcFactory>(*error_server);
186
            return std::make_shared<mtd::StubIpcFactory>(*error_server);
1007
206
        }
187
        }
1008
207
    } server_config;
188
    } server_config;
1009
@@ -218,7 +199,46 @@
1010
218
199
1011
219
            ASSERT_TRUE(connection != NULL);
200
            ASSERT_TRUE(connection != NULL);
1012
220
            EXPECT_FALSE(mir_connection_is_valid(connection));
201
            EXPECT_FALSE(mir_connection_is_valid(connection));
1014
221
            EXPECT_TRUE(std::strstr(mir_connection_get_error_message(connection), ErrorServer::test_exception_text.c_str()));
202
            EXPECT_TRUE(std::strstr(mir_connection_get_error_message(connection), test_exception_text.c_str()));
1015
203
1016
204
            mir_connection_release(connection);
1017
205
        }
1018
206
    } client_config;
1019
207
1020
208
    launch_client_process(client_config);
1021
209
}
1022
210
1023
211
TEST_F(ErrorReporting, c_api_returns_surface_creation_error)
1024
212
{
1025
213
1026
214
    struct ServerConfig : TestingServerConfiguration
1027
215
    {
1028
216
        class BoobytrappedSurfaceFactory : public mir::scene::SurfaceFactory
1029
217
        {
1030
218
            std::shared_ptr<mir::scene::Surface>
1031
219
            create_surface(mir::scene::SurfaceCreationParameters const&) override
1032
220
            {
1033
221
                throw std::runtime_error{test_exception_text};
1034
222
            }
1035
223
        };
1036
224
1037
225
        std::shared_ptr<mir::scene::SurfaceFactory> the_surface_factory() override
1038
226
        {
1039
227
            return std::make_shared<BoobytrappedSurfaceFactory>();
1040
228
        }
1041
229
    } server_config;
1042
230
1043
231
    launch_server_process(server_config);
1044
232
1045
233
    struct ClientConfig : ClientConfigCommon
1046
234
    {
1047
235
        void exec()
1048
236
        {
1049
237
            mir_connect(mir_test_socket, __PRETTY_FUNCTION__, connection_callback, this);
1050
238
1051
239
            wait_for_connect();
1052
240
1053
241
            ASSERT_THAT(connection, IsValid());
1054
222
242
1055
223
            MirSurfaceParameters const request_params =
243
            MirSurfaceParameters const request_params =
1056
224
            {
244
            {
1057
@@ -235,12 +255,7 @@
1058
235
255
1059
236
            ASSERT_TRUE(ssync->surface != NULL);
256
            ASSERT_TRUE(ssync->surface != NULL);
1060
237
            EXPECT_FALSE(mir_surface_is_valid(ssync->surface));
257
            EXPECT_FALSE(mir_surface_is_valid(ssync->surface));
1067
238
            EXPECT_TRUE(std::strstr(mir_surface_get_error_message(ssync->surface), ErrorServer::test_exception_text.c_str()));
258
            EXPECT_TRUE(std::strstr(mir_surface_get_error_message(ssync->surface), test_exception_text.c_str()));
1062
239
1063
240
            EXPECT_NO_THROW({
1064
241
                MirSurfaceParameters response_params;
1065
242
                mir_surface_get_parameters(ssync->surface, &response_params);
1066
243
            });
1068
244
259
1069
245
            mir_surface_release(ssync->surface, release_surface_callback, ssync);
260
            mir_surface_release(ssync->surface, release_surface_callback, ssync);
1070
246
261
1071
247
262
1072
=== modified file 'tests/mir_test/CMakeLists.txt'
1073
--- tests/mir_test/CMakeLists.txt	2014-11-03 04:01:25 +0000
1074
+++ tests/mir_test/CMakeLists.txt	2014-11-05 22:26:46 +0000
1075
@@ -10,6 +10,7 @@
1076
10
  popen.cpp
10
  popen.cpp
1077
11
  wait_object.cpp
11
  wait_object.cpp
1078
12
  current_thread_name.cpp
12
  current_thread_name.cpp
1079
13
  validity_matchers.cpp
1080
13
)
14
)
1081
14
15
1082
15
target_link_libraries(mir-test mirprotobuf)
16
target_link_libraries(mir-test mirprotobuf)
1083
16
17
1084
=== added file 'tests/mir_test/validity_matchers.cpp'
1085
--- tests/mir_test/validity_matchers.cpp	1970-01-01 00:00:00 +0000
1086
+++ tests/mir_test/validity_matchers.cpp	2014-11-05 22:26:46 +0000
1087
@@ -0,0 +1,32 @@
1088
1
#include "mir_test/validity_matchers.h"
1089
2
#include "mir_toolkit/mir_client_library.h"
1090
3
1091
4
template<>
1092
5
bool IsValidMatcher::MatchAndExplain(MirConnection* connection, MatchResultListener* listener) const
1093
6
{
1094
7
    if (connection == nullptr)
1095
8
    {
1096
9
        return false;
1097
10
    }
1098
11
    if (!mir_connection_is_valid(connection))
1099
12
    {
1100
13
        *listener << "error is: " << mir_connection_get_error_message(connection);
1101
14
        return false;
1102
15
    }
1103
16
    return true;
1104
17
}
1105
18
1106
19
template<>
1107
20
bool IsValidMatcher::MatchAndExplain(MirSurface* surface, MatchResultListener* listener) const
1108
21
{
1109
22
    if (surface == nullptr)
1110
23
    {
1111
24
        return false;
1112
25
    }
1113
26
    if (!mir_surface_is_valid(surface))
1114
27
    {
1115
28
        *listener << "error is: " << mir_surface_get_error_message(surface);
1116
29
        return false;
1117
30
    }
1118
31
    return true;
1119
32
}
1120
0
33
1121
=== modified file 'tests/mir_test_framework/using_stub_client_platform.cpp'
1122
--- tests/mir_test_framework/using_stub_client_platform.cpp	2014-10-27 15:22:31 +0000
1123
+++ tests/mir_test_framework/using_stub_client_platform.cpp	2014-11-05 22:26:46 +0000
1124
@@ -17,57 +17,27 @@
1125
17
 */
17
 */
1126
18
18
1127
19
#include "mir_test_framework/using_stub_client_platform.h"
19
#include "mir_test_framework/using_stub_client_platform.h"
1128
20
#include "mir_test_framework/stub_client_connection_configuration.h"
1129
21
#include "mir_toolkit/mir_client_library.h"
20
#include "mir_toolkit/mir_client_library.h"
1130
22
#include "src/client/mir_connection_api.h"
1131
23
21
1132
24
namespace mtf = mir_test_framework;
22
namespace mtf = mir_test_framework;
1133
25
namespace mcl = mir::client;
23
namespace mcl = mir::client;
1134
26
24
1146
27
namespace
25
MirWaitHandle* mtf::StubMirConnectionAPI::connect(
1147
28
{
26
        mcl::ConfigurationFactory /*configuration*/,
1137
29
class StubMirConnectionAPI : public mcl::MirConnectionAPI
1138
30
{
1139
31
public:
1140
32
    StubMirConnectionAPI(mcl::MirConnectionAPI* prev_api)
1141
33
        : prev_api{prev_api}
1142
34
    {
1143
35
    }
1144
36
1145
37
    MirWaitHandle* connect(
1148
38
        char const* socket_file,
27
        char const* socket_file,
1149
39
        char const* name,
28
        char const* name,
1150
40
        mir_connected_callback callback,
29
        mir_connected_callback callback,
1183
41
        void* context) override
30
        void* context)
1184
42
    {
31
{
1185
43
        return prev_api->connect(socket_file, name, callback, context);
32
    return prev_api->connect(configuration_factory(), socket_file, name, callback, context);
1186
44
    }
33
}
1187
45
34
1188
46
    void release(MirConnection* connection) override
35
void mtf::StubMirConnectionAPI::release(MirConnection* connection)
1189
47
    {
36
{
1190
48
        return prev_api->release(connection);
37
    return prev_api->release(connection);
1191
49
    }
38
}
1192
50
39
1193
51
    std::unique_ptr<mcl::ConnectionConfiguration> configuration(std::string const& socket) override
40
mcl::ConfigurationFactory mtf::StubMirConnectionAPI::configuration_factory()
1194
52
    {
41
{
1195
53
        return std::unique_ptr<mcl::ConnectionConfiguration>{
42
    return factory;
1164
54
            new mtf::StubConnectionConfiguration{socket}};
1165
55
    }
1166
56
1167
57
private:
1168
58
    mcl::MirConnectionAPI* const prev_api;
1169
59
};
1170
60
1171
61
}
1172
62
1173
63
mtf::UsingStubClientPlatform::UsingStubClientPlatform()
1174
64
    : prev_api{mir_connection_api_impl},
1175
65
      stub_api{new StubMirConnectionAPI{prev_api}}
1176
66
{
1177
67
    mir_connection_api_impl = stub_api.get();
1178
68
}
1179
69
1180
70
mtf::UsingStubClientPlatform::~UsingStubClientPlatform()
1181
71
{
1182
72
    mir_connection_api_impl = prev_api;
1196
73
}
43
}
Reviewer	Review Type	Date Requested	Status
Alberto Aguirre (community)			Approve on 2014-11-08
Alan Griffiths			Approve on 2014-11-07
PS Jenkins bot (community)	continuous-integration		Approve on 2014-11-05
Robert Carr (community)		2014-08-28	Needs Information on 2014-09-03
Review via email: mp+232508@code.launchpad.net