Merge lp:~afrantzis/mir/variable-length-serialization-buffers-1320187 into lp:mir

[Alexandros Frantzis]

frontend,rpc: Ensure serialization buffers are always capable of fitting sent/received messages

frontend,rpc: Ensure serialization buffers are always capable of fitting sent/received messages

... while keeping the amount of heap allocations low.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1637
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1653/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/225
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/226
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/226
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/172
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/172/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/171
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/171/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/573
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/573/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1478
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/7277

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1653/rebuild

review: Approve (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

What is the purpose of connection_to_server_with_large_display_configuration_succeeds in test_large_messages.cpp?

review: Needs Information

[Alexandros Frantzis (afrantzis)]

> What is the purpose of
> connection_to_server_with_large_display_configuration_succeeds in
> test_large_messages.cpp?

Clarified purpose of test in new comment:

370 +// Regression test for lp:1320187. Without a fix for that bug, connecting
371 +// to a server with a lot of information in the display configuration hangs
372 +// the client, because the server reply message is incomplete/corrupted.

[Alan Griffiths (alan-griffiths)]

59 + static void heap_deleter(unsigned char* b) { if (b != nullptr) delete[] b; }

It is safe to call delete[] with nullptr (and doing so avoids the test here as well as in the library)

~~~~

345 +struct LargeMessages : mir_test_framework::InProcessServer
346 +{
347 + LargeMessagesServerConfiguration large_messages_server_config;
348 +
349 + mir::DefaultServerConfiguration& server_config() override
350 + {
351 + return large_messages_server_config;
352 + }
353 +};
354
355 +struct ConnectionContext
356 +{
357 + mt::WaitObject connected;
358 + MirConnection* connection{nullptr};
359 +};
360 +
361 +void connection_callback(MirConnection* connection, void* context)
362 +{
363 + auto connection_context = static_cast<ConnectionContext*>(context);
364 + connection_context->connection = connection;
365 + connection_context->connected.notify_ready();
366 +}

You could avoid this (and some related code in the test body) by:

using LargeMessages = mir_test_framework::BasicClientServerFixture<LargeMessagesServerConfiguration>;

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1638
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1664/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/236
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/237
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/237
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/183
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/183/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/182
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/182/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/619
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/619/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1489
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/7327

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1664/rebuild

review: Approve (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

> > What is the purpose of
> > connection_to_server_with_large_display_configuration_succeeds in
> > test_large_messages.cpp?
>
> Clarified purpose of test in new comment:
>
> 370 +// Regression test for lp:1320187. Without a fix for that bug,
> connecting
> 371 +// to a server with a lot of information in the display configuration
> hangs
> 372 +// the client, because the server reply message is
> incomplete/corrupted.

oh, ok.

review: Approve

[Alexandros Frantzis (afrantzis)]

> It is safe to call delete[] with nullptr (and doing so avoids the test here as well as in the library)

Fixed.

> You could avoid this (and some related code in the test body) by:
> using LargeMessages = mir_test_framework::BasicClientServerFixture<LargeMessagesServerConfiguration>;

Without the fix, the client hangs indefinitely in mir_connect, so I need to make the connect call async to be able to make the test fail after a reasonable amount of time.

[Alan Griffiths (alan-griffiths)]

> > You could avoid this (and some related code in the test body) by:
> > using LargeMessages = mir_test_framework::BasicClientServerFixture<LargeMess
> agesServerConfiguration>;
>
> Without the fix, the client hangs indefinitely in mir_connect, so I need to
> make the connect call async to be able to make the test fail after a
> reasonable amount of time.

I see. I guess this is too "clever"...

template<>
void BasicClientServerFixture<LargeMessagesServerConfiguration>::SetUp()
{
    InProcessServer::SetUp();
    // async connect with timeout
}

...OTOH maybe changing BasicClientServerFixture to timeout & fail instead of hang is a good idea for the general case.

Anyway I'm still approving as is. ;)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1639
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1667/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/239
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/240
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/240
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/186
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/186/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/185
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/185/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/626
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/626/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1492
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/7338

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1667/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

review: Approve

[Alberto Aguirre (albaguirre)]

LGTM

review: Approve

=== added file 'include/shared/mir/variable_length_array.h'
--- include/shared/mir/variable_length_array.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/variable_length_array.h	2014-05-19 12:37:31 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_VARIABLE_LENGTH_ARRAY_H_
+#define MIR_VARIABLE_LENGTH_ARRAY_H_
+
+#include <sys/types.h>
+#include <memory>
+
+namespace mir
+{
+
+template <size_t BuiltInBufferSize>
+class VariableLengthArray
+{
+public:
+    explicit VariableLengthArray(size_t size) : size_{size}
+    {
+        /* Don't call resize if the initial values of member variables are valid */
+        if (size > BuiltInBufferSize) resize(size);
+    }
+
+    void resize(size_t size)
+    {
+        if (size > BuiltInBufferSize)
+            effective_buffer = BufferUPtr{new unsigned char[size], heap_deleter};
+        else
+            effective_buffer = BufferUPtr{builtin_buffer, null_deleter};
+
+        size_ = size;
+    }
+
+    unsigned char* data() const { return effective_buffer.get(); }
+    size_t size() const { return size_; }
+
+private:
+    typedef std::unique_ptr<unsigned char,void (*)(unsigned char*)> BufferUPtr;
+
+    static void null_deleter(unsigned char*) {}
+    static void heap_deleter(unsigned char* b) { delete[] b; }
+
+    unsigned char builtin_buffer[BuiltInBufferSize];
+    BufferUPtr effective_buffer{builtin_buffer, null_deleter};
+    size_t size_;
+};
+
+}
+
+#endif /* MIR_VARIABLE_LENGTH_ARRAY_H_ */

=== modified file 'src/client/rpc/mir_basic_rpc_channel.cpp'
--- src/client/rpc/mir_basic_rpc_channel.cpp	2014-03-26 05:48:59 +0000
+++ src/client/rpc/mir_basic_rpc_channel.cpp	2014-05-19 12:37:31 +0000
@@ -21,6 +21,7 @@
 
 #include "mir_protobuf_wire.pb.h"
 #include "mir/frontend/client_constants.h"
+#include "mir/variable_length_array.h"
 
 #include <sstream>
 
@@ -105,19 +106,16 @@
     google::protobuf::MethodDescriptor const* method,
     google::protobuf::Message const* request)
 {
-    char buffer[mir::frontend::serialization_buffer_size];
-
-    auto const size = request->ByteSize();
-    // In practice size will be 10s of bytes - but have a test to detect problems
-    assert(size < static_cast<decltype(size)>(sizeof buffer));
-
-    request->SerializeToArray(buffer, sizeof buffer);
+    mir::VariableLengthArray<mir::frontend::serialization_buffer_size>
+        buffer{static_cast<size_t>(request->ByteSize())};
+
+    request->SerializeWithCachedSizesToArray(buffer.data());
 
     mir::protobuf::wire::Invocation invoke;
 
     invoke.set_id(next_id());
     invoke.set_method_name(method->name());
-    invoke.set_parameters(buffer, size);
+    invoke.set_parameters(buffer.data(), buffer.size());
     invoke.set_protocol_version(1);
 
     return invoke;

=== modified file 'src/server/frontend/event_sender.cpp'
--- src/server/frontend/event_sender.cpp	2014-03-26 05:48:59 +0000
+++ src/server/frontend/event_sender.cpp	2014-05-19 12:37:31 +0000
@@ -18,6 +18,7 @@
 
 #include "mir/frontend/client_constants.h"
 #include "mir/graphics/display_configuration.h"
+#include "mir/variable_length_array.h"
 #include "event_sender.h"
 #include "message_sender.h"
 #include "protobuf_buffer_packer.h"
@@ -73,17 +74,19 @@
 
 void mfd::EventSender::send_event_sequence(mp::EventSequence& seq)
 {
-    std::string send_buffer;
-    send_buffer.reserve(serialization_buffer_size);
-    seq.SerializeToString(&send_buffer);
+    mir::VariableLengthArray<frontend::serialization_buffer_size>
+        send_buffer{static_cast<size_t>(seq.ByteSize())};
+
+    seq.SerializeWithCachedSizesToArray(send_buffer.data());
 
     mir::protobuf::wire::Result result;
-    result.add_events(send_buffer);
-    result.SerializeToString(&send_buffer);
+    result.add_events(send_buffer.data(), send_buffer.size());
+    send_buffer.resize(result.ByteSize());
+    result.SerializeWithCachedSizesToArray(send_buffer.data());
 
     try
     {
-        sender->send(send_buffer.data(), send_buffer.length(), {});
+        sender->send(reinterpret_cast<char*>(send_buffer.data()), send_buffer.size(), {});
     }
     catch (std::exception const& error)
     {

=== modified file 'src/server/frontend/protobuf_responder.cpp'
--- src/server/frontend/protobuf_responder.cpp	2014-03-26 05:48:59 +0000
+++ src/server/frontend/protobuf_responder.cpp	2014-05-19 12:37:31 +0000
@@ -20,6 +20,7 @@
 #include "resource_cache.h"
 #include "message_sender.h"
 #include "mir/frontend/client_constants.h"
+#include "mir/variable_length_array.h"
 #include "socket_messenger.h"
 
 namespace mfd = mir::frontend::detail;
@@ -28,8 +29,7 @@
     std::shared_ptr<MessageSender> const& sender,
     std::shared_ptr<ResourceCache> const& resource_cache) :
     sender(sender),
-    resource_cache(resource_cache),
-    send_response_buffer(serialization_buffer_size)
+    resource_cache(resource_cache)
 {
 }
 
@@ -38,13 +38,17 @@
     google::protobuf::Message* response,
     FdSets const& fd_sets)
 {
-    response->SerializeToArray(send_response_buffer.data(), send_response_buffer.size());
+    mir::VariableLengthArray<serialization_buffer_size>
+        send_response_buffer{static_cast<size_t>(response->ByteSize())};
+
+    response->SerializeWithCachedSizesToArray(send_response_buffer.data());
 
     send_response_result.set_id(id);
-    send_response_result.set_response(send_response_buffer.data(), response->ByteSize());
-
-    send_response_result.SerializeToArray(send_response_buffer.data(), send_response_buffer.size());
-
-    sender->send(send_response_buffer.data(), send_response_result.ByteSize(), fd_sets);
+    send_response_result.set_response(send_response_buffer.data(), send_response_buffer.size());
+
+    send_response_buffer.resize(send_response_result.ByteSize());
+    send_response_result.SerializeWithCachedSizesToArray(send_response_buffer.data());
+
+    sender->send(reinterpret_cast<char*>(send_response_buffer.data()), send_response_buffer.size(), fd_sets);
     resource_cache->free_resource(response);
 }

=== modified file 'src/server/frontend/protobuf_responder.h'
--- src/server/frontend/protobuf_responder.h	2014-03-26 05:48:59 +0000
+++ src/server/frontend/protobuf_responder.h	2014-05-19 12:37:31 +0000
@@ -50,7 +50,6 @@
     std::shared_ptr<MessageSender> const sender;
     std::shared_ptr<ResourceCache> const resource_cache;
 
-    std::vector<char> send_response_buffer;
     mir::protobuf::wire::Result send_response_result;
 };
 }

=== modified file 'src/server/frontend/socket_messenger.cpp'
--- src/server/frontend/socket_messenger.cpp	2014-05-14 06:34:25 +0000
+++ src/server/frontend/socket_messenger.cpp	2014-05-19 12:37:31 +0000
@@ -19,6 +19,7 @@
 #include "socket_messenger.h"
 #include "mir/frontend/client_constants.h"
 #include "mir/frontend/session_credentials.h"
+#include "mir/variable_length_array.h"
 
 #include <errno.h>
 #include <string.h>
@@ -33,7 +34,6 @@
 mfd::SocketMessenger::SocketMessenger(std::shared_ptr<ba::local::stream_protocol::socket> const& socket)
     : socket(socket)
 {
-    whole_message.reserve(serialization_buffer_size);
 }
 
 mf::SessionCredentials mfd::SocketMessenger::client_creds()
@@ -43,25 +43,21 @@
 
 void mfd::SocketMessenger::send(char const* data, size_t length, FdSets const& fd_set)
 {
-    const unsigned char header_bytes[2] =
-    {
-        static_cast<unsigned char>((length >> 8) & 0xff),
-        static_cast<unsigned char>((length >> 0) & 0xff)
-    };
+    static size_t const header_size{2};
+    mir::VariableLengthArray<mf::serialization_buffer_size> whole_message{header_size + length};
+
+    whole_message.data()[0] = static_cast<unsigned char>((length >> 8) & 0xff);
+    whole_message.data()[1] = static_cast<unsigned char>((length >> 0) & 0xff);
+    std::copy(data, data + length, whole_message.data() + header_size);
 
     std::unique_lock<std::mutex> lg(message_lock);
 
-    whole_message.resize(sizeof header_bytes + length);
-    std::copy(header_bytes, header_bytes + sizeof header_bytes, whole_message.begin());
-    std::copy(data, data + length, whole_message.begin() + sizeof header_bytes);
-
-
     // TODO: This should be asynchronous, but we are not making sure
     // that a potential call to send_fds is executed _after_ this
     // function has completed (if it would be executed asynchronously.
     // NOTE: we rely on this synchronous behavior as per the comment in
     // mf::SessionMediator::create_surface
-    ba::write(*socket, ba::buffer(whole_message));
+    ba::write(*socket, ba::buffer(whole_message.data(), whole_message.size()));
 
     for (auto const& fds : fd_set)
         send_fds_locked(lg, fds);

=== modified file 'src/server/frontend/socket_messenger.h'
--- src/server/frontend/socket_messenger.h	2014-05-05 03:36:45 +0000
+++ src/server/frontend/socket_messenger.h	2014-05-19 12:37:31 +0000
@@ -45,8 +45,6 @@
     std::shared_ptr<boost::asio::local::stream_protocol::socket> socket;
 
     std::mutex message_lock;
-    std::vector<char> whole_message;
-
     void send_fds_locked(std::unique_lock<std::mutex> const& lock, std::vector<int32_t> const& fds);
 };
 }

=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2014-05-13 03:57:36 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2014-05-19 12:37:31 +0000
@@ -33,6 +33,7 @@
   test_client_surface_swap_buffers.cpp
   test_client_cursor_api.cpp
   test_trust_session_helper.cpp
+  test_large_messages.cpp
   ${GENERATED_PROTOBUF_SRCS}
   ${GENERATED_PROTOBUF_HDRS}
 )

=== added file 'tests/acceptance-tests/test_large_messages.cpp'
--- tests/acceptance-tests/test_large_messages.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/test_large_messages.cpp	2014-05-19 12:37:31 +0000
@@ -0,0 +1,103 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "mir_test_framework/in_process_server.h"
+#include "mir_test_framework/stubbed_server_configuration.h"
+#include "mir_test/wait_object.h"
+#include "mir_test/fake_shared.h"
+#include "mir_test_doubles/stub_display_configuration.h"
+#include "mir_test_doubles/null_display_changer.h"
+
+#include "mir_toolkit/mir_connection.h"
+
+#include <gtest/gtest.h>
+
+namespace mtd = mir::test::doubles;
+namespace mt = mir::test;
+namespace mg = mir::graphics;
+namespace mf = mir::frontend;
+
+namespace
+{
+
+class LargeDisplayConfigChanger : public mtd::NullDisplayChanger
+{
+public:
+    std::shared_ptr<mg::DisplayConfiguration> active_configuration() override
+    {
+        return mt::fake_shared(stub_display_config);
+    }
+
+private:
+    mtd::StubDisplayConfig stub_display_config{20};
+};
+
+
+struct LargeMessagesServerConfiguration : mir_test_framework::StubbedServerConfiguration
+{
+    std::shared_ptr<mf::DisplayChanger> the_frontend_display_changer() override
+    {
+        return mt::fake_shared(large_display_config_changer);
+    }
+
+    LargeDisplayConfigChanger large_display_config_changer;
+};
+
+struct LargeMessages : mir_test_framework::InProcessServer
+{
+    LargeMessagesServerConfiguration large_messages_server_config;
+
+    mir::DefaultServerConfiguration& server_config() override
+    {
+        return large_messages_server_config;
+    }
+};
+
+struct ConnectionContext
+{
+    mt::WaitObject connected;
+    MirConnection* connection{nullptr};
+};
+
+void connection_callback(MirConnection* connection, void* context)
+{
+    auto connection_context = static_cast<ConnectionContext*>(context);
+    connection_context->connection = connection;
+    connection_context->connected.notify_ready();
+}
+
+}
+
+// Regression test for lp:1320187. Without a fix for that bug, connecting
+// to a server with a lot of information in the display configuration hangs
+// the client, because the server reply message is incomplete/corrupted.
+TEST_F(LargeMessages, connection_to_server_with_large_display_configuration_succeeds)
+{
+    using namespace testing;
+
+    ConnectionContext connection_context;
+
+    mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__,
+                connection_callback, &connection_context);
+
+    connection_context.connected.wait_until_ready(std::chrono::seconds{3});
+
+    EXPECT_NE(connection_context.connection, nullptr);
+
+    mir_connection_release(connection_context.connection);
+}

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2014-03-26 05:48:59 +0000
+++ tests/unit-tests/CMakeLists.txt	2014-05-19 12:37:31 +0000
@@ -12,6 +12,7 @@
   shared_library_test.cpp
   test_raii.cpp
   test_udev_wrapper.cpp
+  test_variable_length_array.cpp
 )
 
 add_subdirectory(options/)

=== added file 'tests/unit-tests/test_variable_length_array.cpp'
--- tests/unit-tests/test_variable_length_array.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_variable_length_array.cpp	2014-05-19 12:37:31 +0000
@@ -0,0 +1,107 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "mir/variable_length_array.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+TEST(VariableLengthArray, has_correct_size_if_using_builtin)
+{
+    using namespace testing;
+
+    size_t const builtin_size{100};
+    size_t const vla_size_builtin{builtin_size - 1};
+    mir::VariableLengthArray<builtin_size> vla{vla_size_builtin};
+
+    EXPECT_THAT(vla.size(), Eq(vla_size_builtin));
+    memset(vla.data(), 0x55, vla.size());
+}
+
+TEST(VariableLengthArray, has_correct_size_if_using_heap)
+{
+    using namespace testing;
+
+    size_t const builtin_size{100};
+    size_t const vla_size_heap{builtin_size + 1};
+    mir::VariableLengthArray<builtin_size> vla{vla_size_heap};
+
+    EXPECT_THAT(vla.size(), Eq(vla_size_heap));
+    memset(vla.data(), 0x55, vla.size());
+}
+
+TEST(VariableLengthArray, resizes_from_builtin_to_heap)
+{
+    using namespace testing;
+
+    size_t const builtin_size{100};
+    size_t const vla_size_builtin{builtin_size - 1};
+    size_t const vla_size_heap{builtin_size + 1};
+    mir::VariableLengthArray<builtin_size> vla{vla_size_builtin};
+
+    vla.resize(vla_size_heap);
+
+    EXPECT_THAT(vla.size(), Eq(vla_size_heap));
+    memset(vla.data(), 0x55, vla.size());
+}
+
+TEST(VariableLengthArray, resizes_from_builtin_to_builtin)
+{
+    using namespace testing;
+
+    size_t const builtin_size{100};
+    size_t const vla_size_builtin1{builtin_size - 1};
+    size_t const vla_size_builtin2{builtin_size};
+    mir::VariableLengthArray<builtin_size> vla{vla_size_builtin1};
+
+    vla.resize(vla_size_builtin2);
+
+    EXPECT_THAT(vla.size(), Eq(vla_size_builtin2));
+    memset(vla.data(), 0x55, vla.size());
+}
+
+TEST(VariableLengthArray, resizes_from_heap_to_builtin)
+{
+    using namespace testing;
+
+    size_t const builtin_size{100};
+    size_t const vla_size_builtin{builtin_size - 1};
+    size_t const vla_size_heap{builtin_size + 1};
+    mir::VariableLengthArray<builtin_size> vla{vla_size_heap};
+
+    vla.resize(vla_size_builtin);
+
+    EXPECT_THAT(vla.size(), Eq(vla_size_builtin));
+    memset(vla.data(), 0x55, vla.size());
+}
+
+TEST(VariableLengthArray, resizes_from_heap_to_heap)
+{
+    using namespace testing;
+
+    size_t const builtin_size{100};
+    size_t const vla_size_heap1{builtin_size + 1};
+    size_t const vla_size_heap2{builtin_size + 2};
+    mir::VariableLengthArray<builtin_size> vla{vla_size_heap1};
+
+    vla.resize(vla_size_heap2);
+
+    EXPECT_THAT(vla.size(), Eq(vla_size_heap2));
+    memset(vla.data(), 0x55, vla.size());
+}