Merge lp:~kdub/mir/bstream-integration-test2 into lp:mir

[Kevin DuBois]

new buffer semantics: add more tests (inspired by the BufferQueue tests) to the BufferStream integration test.

new buffer semantics: add more tests (inspired by the BufferQueue tests) to the BufferStream integration test.

note: I've been tracking the translations in a gdoc:
https://docs.google.com/spreadsheets/d/1pbmEx78Gl7lTRE4zVRE4zMbfvVaNA1NmPgOjg4Vr3is/edit#gid=0
still quite a few to go.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2707
http://jenkins.qa.ubuntu.com/job/mir-ci/4253/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3077
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/598/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3025
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/409
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/409/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3025
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3025/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5835
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21638

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

review: Needs Fixing (continuous-integration)

[Chris Halse Rogers (raof)]

Quite a lot of these tests don't seem to make sense in my conception of the future allocate/submit model.

Hm. I kinda feel that these tests are going to be more a test of the emulate-current-semantics test code that we'll need to write just for these tests when we switch to allocate/submit.

review: Needs Information

[Kevin DuBois (kdub)]

> Quite a lot of these tests don't seem to make sense in my conception of the
> future allocate/submit model.
>
> Hm. I kinda feel that these tests are going to be more a test of the emulate-
> current-semantics test code that we'll need to write just for these tests when
> we switch to allocate/submit.

If BufferQueue and the "new semantics" were in a classic 2-bubble Venn diagram, this test suite's aim is only to capture the stuff in the middle. BufferQueue has some testing around its callback-based interfaces in its unit test, and "new semantics" will need more testing than this suite for its multiple-buffers approach.

The strategy here is to have the client-to-server (+vice versa) "connections" in the stubs, and the endpoints in the tests. The connections between client and server will have to be different in the two models; but with the stub-glue, the overarching behavior, as observed at the production and consumption endpoints, hopefully will be the same for the behaviors in the middle of the Venn diagram (which is what we can 'regress' on, and have to make sure we move the code while still under test coverage)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2708
http://jenkins.qa.ubuntu.com/job/mir-ci/4257/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3082
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/603
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3030
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/413
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/413/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3030
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3030/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5840
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21669

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

review: Approve (continuous-integration)

[Chris Halse Rogers (raof)]

I think I understand what the purpose of the tests are, I just disagree that they're all in the intersection of the Venn diagram :)

Particularly:
+TEST_P(WithTwoOrMoreBuffers, consumer_cycles_through_all_available_buffers)
What is this supposed to test in the acquire/submit framework? Of course the client sees all the available buffers; it's allocated them explicitly.

+TEST_P(WithTwoOrMoreBuffers, framedropping_clients_get_all_buffers)
What is this trying to test in the acquire/submit framework? The client always gets as many buffers as they allocate.

+TEST_P(WithAnyNumberOfBuffers, resize_affects_client_acquires_immediately)
This is kinda testable, but is only going to test the test code in an acquire/submit model. The client gets a resized buffer exactly when the client allocates a freshly sized buffer.

+TEST_P(WithOneBuffer, with_single_buffer_compositor_acquires_resized_frames_eventually)
Single buffered clients remain nonsensical in a composited environment :). But again, as above, a client will acquire a resized buffer exactly when it allocates one.

+TEST_P(WithTwoOrMoreBuffers, nonframedropping_client_throttles_to_compositor_rate)
+TEST_P(WithTwoOrMoreBuffers, uncomposited_client_swaps_when_policy_triggered)
+TEST_P(WithTwoBuffers, client_is_not_blocked_prematurely)
Under acquire/submit we never block a client. As such, these tests are going to heavily depend on the test-code emulating the current semantics where we *do* block. They might still be worthwhile tests to ensure that sensibly-written clients get sensible behaviour, though?

I think the buffers_ready tests are also candidates for not-in-the-intersection.

Other issues:
+TEST_P(WithAnyNumberOfBuffers, compositor_can_always_get_a_buffer)
This makes sense, but there should be a produce first, otherwise there's no buffer for the compositor.

[Kevin DuBois (kdub)]

> I think I understand what the purpose of the tests are, I just disagree that
> they're all in the intersection of the Venn diagram :)

> Particularly:
> +TEST_P(WithTwoOrMoreBuffers, consumer_cycles_through_all_available_buffers)
> What is this supposed to test in the acquire/submit framework? Of course the
> client sees all the available buffers; it's allocated them explicitly.

Its not that its checking that all are seen by the client, but that the buffers are cycled through. In the current version, the test expectations have gotten a little weaker, so I improved to make more sense.

> +TEST_P(WithTwoOrMoreBuffers, framedropping_clients_get_all_buffers)
> What is this trying to test in the acquire/submit framework? The client always
> gets as many buffers as they allocate.

Ack, was a bit unclear. I guess that the original test was mostly testing that it cycles through the buffers, and doesn't block the client when framedropping is on, improved test name and code to be more obvious.

> +TEST_P(WithAnyNumberOfBuffers, resize_affects_client_acquires_immediately)
> This is kinda testable, but is only going to test the test code in an
> acquire/submit model. The client gets a resized buffer exactly when the client
> allocates a freshly sized buffer.

I'm okay to have tests in the suite that have to have some more rigging for the new system. Maybe in working on the resize code, I can figure out a way at that point to make it more applicable to both systems.

> +TEST_P(WithOneBuffer,
> with_single_buffer_compositor_acquires_resized_frames_eventually)
> Single buffered clients remain nonsensical in a composited environment :). But
> again, as above, a client will acquire a resized buffer exactly when it
> allocates one.

Also makes less sense in a fencing system too :) And, yes, was redundant. Removed.

> +TEST_P(WithTwoOrMoreBuffers,
> nonframedropping_client_throttles_to_compositor_rate)
> +TEST_P(WithTwoOrMoreBuffers, uncomposited_client_swaps_when_policy_triggered)
> +TEST_P(WithTwoBuffers, client_is_not_blocked_prematurely)
> Under acquire/submit we never block a client. As such, these tests are going
> to heavily depend on the test-code emulating the current semantics where we
> *do* block. They might still be worthwhile tests to ensure that sensibly-
> written clients get sensible behaviour, though?
>
> I think the buffers_ready tests are also candidates for not-in-the-
> intersection.

We can still hamper a client to the point that they're blocked if we're not sending buffers back when they're ready. Its a bit tricky to see how the test rigging will evolve, but seems useful to keep them around, at least until the new code starts becoming a bit more concrete.

> Other issues:
> +TEST_P(WithAnyNumberOfBuffers, compositor_can_always_get_a_buffer)
> This makes sense, but there should be a produce first, otherwise there's no
> buffer for the compositor.

fixed.

Also, thanks for reviewing! (probably a pain to review, hoping that the spreadsheet is/was somewhat helpful)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2712
http://jenkins.qa.ubuntu.com/job/mir-ci/4268/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3087
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/608
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3035
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/417
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/417/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3035
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3035/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5845
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21691

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

review: Approve (continuous-integration)

[Chris Halse Rogers (raof)]

Yeah. I still suspect that a bunch of these will end up being not worthwhile tests, but maybe I'll be wrong, and it's harmless to keep them in here until the new code is here to test :)

review: Approve

[Alexandros Frantzis (afrantzis)]

Looks good.

Like Chris I am not sure if all of these will make sense eventually, but I guess it's better to have them and remove them later if we don't need them, than to regress because we missed a test.

review: Approve

=== modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
--- tests/integration-tests/test_buffer_scheduling.cpp	2015-06-26 18:19:01 +0000
+++ tests/integration-tests/test_buffer_scheduling.cpp	2015-07-07 11:42:17 +0000
@@ -22,6 +22,7 @@
 #include "mir/test/doubles/mock_client_buffer_factory.h"
 #include "mir/test/doubles/stub_buffer_allocator.h"
 #include "mir/test/doubles/stub_frame_dropping_policy_factory.h"
+#include "mir/test/doubles/mock_frame_dropping_policy_factory.h"
 #include "mir/test/fake_shared.h"
 #include <gtest/gtest.h>
 
@@ -35,18 +36,26 @@
 
 namespace
 {
+enum class Access
+{
+    blocked,
+    unblocked
+};
+
 struct BufferEntry
 {
     mg::BufferID id;
     unsigned int age;
+    Access blockage;
     bool operator==(BufferEntry const& b) const
     {
-        return ((id == b.id) && (age == b.age));
+        return ((blockage == b.blockage) && (id == b.id) && (age == b.age));
     }
 };
 
 struct ProducerSystem
 {
+    virtual bool can_produce() = 0;
     virtual void produce() = 0;
     virtual std::vector<BufferEntry> production_log() = 0;
     virtual ~ProducerSystem() = default;
@@ -75,18 +84,32 @@
             std::bind(&BufferQueueProducer::buffer_ready, this, std::placeholders::_1));
     }
 
+    bool can_produce()
+    {
+        std::unique_lock<decltype(mutex)> lk(mutex);
+        return buffer;
+    }
+
     void produce()
     {
         mg::Buffer* b = nullptr;
-        {
-            std::unique_lock<decltype(mutex)> lk(mutex);
-            b = buffer;
-            age++;
-            entries.emplace_back(BufferEntry{b->id(), age});
-            buffer->write(reinterpret_cast<unsigned char const*>(&age), sizeof(age));
-        }
-        stream.swap_buffers(b,
-            std::bind(&BufferQueueProducer::buffer_ready, this, std::placeholders::_1));
+        if (can_produce())
+        {
+            {
+                std::unique_lock<decltype(mutex)> lk(mutex);
+                b = buffer;
+                buffer = nullptr;
+                age++;
+                entries.emplace_back(BufferEntry{b->id(), age, Access::unblocked});
+                b->write(reinterpret_cast<unsigned char const*>(&age), sizeof(age));
+            }
+            stream.swap_buffers(b,
+                std::bind(&BufferQueueProducer::buffer_ready, this, std::placeholders::_1));
+        }
+        else
+        {
+            entries.emplace_back(BufferEntry{mg::BufferID{2}, 0u, Access::blocked});
+        }
     }
 
     std::vector<BufferEntry> production_log()
@@ -95,6 +118,12 @@
         return entries;
     }
 
+    geom::Size last_size()
+    {
+        if (buffer)
+            return buffer->size();
+        return geom::Size{};
+    }
 private:
     mc::BufferStream& stream;
     void buffer_ready(mg::Buffer* b)
@@ -118,8 +147,9 @@
     void consume()
     {
         auto b = stream.lock_compositor_buffer(this);
+        last_size_ = b->size();
         b->read([this, b](unsigned char const* p) {
-            entries.emplace_back(BufferEntry{b->id(), *reinterpret_cast<unsigned int const*>(p)});
+            entries.emplace_back(BufferEntry{b->id(), *reinterpret_cast<unsigned int const*>(p), Access::unblocked});
         });
     }
 
@@ -127,8 +157,15 @@
     {
         return entries;
     }
+
+    geom::Size last_size()
+    {
+        return last_size_;
+    }
+    
     mc::BufferStream& stream;
     std::vector<BufferEntry> entries;
+    geom::Size last_size_;
 };
 
 //schedule helpers
@@ -161,6 +198,30 @@
     }
 }
 
+void repeat_system_until(
+    std::vector<ScheduleEntry>& schedule,
+    std::function<bool()> const& predicate)
+{
+    std::sort(schedule.begin(), schedule.end(),
+        [](ScheduleEntry& a, ScheduleEntry& b)
+        {
+            return a.timestamp < b.timestamp;
+        });
+
+    auto entry_it = schedule.begin();
+    if (entry_it == schedule.end()) return;
+    while(predicate())
+    {
+        for(auto const& p : entry_it->producers)
+            p->produce();
+        for(auto const& c : entry_it->consumers)
+            c->consume();
+        entry_it++;
+        if (entry_it == schedule.end()) entry_it = schedule.begin();
+    }
+}
+
+
 //test infrastructure
 struct BufferScheduling : public Test, ::testing::WithParamInterface<int>
 {
@@ -174,12 +235,17 @@
     mc::BufferStreamSurfaces stream{mt::fake_shared(queue)};
     BufferQueueProducer producer{stream};
     BufferQueueConsumer consumer{stream};
+    BufferQueueConsumer second_consumer{stream};
 };
 struct WithAnyNumberOfBuffers : BufferScheduling {};
 struct WithTwoOrMoreBuffers   : BufferScheduling {};
 struct WithThreeOrMoreBuffers : BufferScheduling {};
+struct WithOneBuffer : BufferScheduling {};
+struct WithTwoBuffers : BufferScheduling {};
+struct WithThreeBuffers : BufferScheduling {};
 }
 
+/* Regression test for LP#1270964 */
 TEST_P(WithAnyNumberOfBuffers, all_buffers_consumed_in_interleaving_pattern)
 {
     std::vector<ScheduleEntry> schedule = {
@@ -241,6 +307,436 @@
     EXPECT_THAT(consumption_log, ContainerEq(production_log));
 }
 
+
+MATCHER_P(EachBufferIdIs, value, "")
+{
+    auto id_matcher = [](BufferEntry const& a, BufferEntry const& b){ return a.id == b.id; };
+    return std::search_n(arg.begin(), arg.end(), arg.size(), value, id_matcher) != std::end(arg);
+}
+
+MATCHER(HasIncreasingAge, "")
+{
+    return std::is_sorted(arg.begin(), arg.end(),
+        [](BufferEntry const& a, BufferEntry const& b) {
+            return a.age < b.age;
+        });
+}
+
+TEST_P(WithOneBuffer, client_and_server_get_concurrent_access)
+{
+    std::vector<ScheduleEntry> schedule = {
+        {1_t, {&producer}, {&consumer}},
+        {2_t, {&producer}, {&consumer}},
+        {3_t, {&producer}, {}},
+        {4_t,          {}, {&consumer}},
+    };
+    run_system(schedule);
+
+    auto production_log = producer.production_log();
+    auto consumption_log = consumer.consumption_log();
+    EXPECT_THAT(production_log, Not(IsEmpty()));
+    EXPECT_THAT(consumption_log, Not(IsEmpty()));
+    EXPECT_THAT(consumption_log, ContainerEq(production_log));
+
+    EXPECT_THAT(consumption_log, EachBufferIdIs(consumption_log[0]));
+    EXPECT_THAT(production_log, EachBufferIdIs(consumption_log[0]));
+    EXPECT_THAT(consumption_log, HasIncreasingAge());
+} 
+
+
+/* Regression test for LP: #1210042 */
+TEST_P(WithThreeOrMoreBuffers, consumers_dont_recycle_startup_buffer )
+{
+    std::vector<ScheduleEntry> schedule = {
+        {1_t, {&producer}, {}},
+        {2_t, {&producer}, {}},
+        {3_t,          {}, {&consumer}},
+    };
+    run_system(schedule);
+
+    auto production_log = producer.production_log();
+    auto consumption_log = consumer.consumption_log();
+    ASSERT_THAT(production_log, SizeIs(2)); 
+    ASSERT_THAT(consumption_log, SizeIs(1));
+    EXPECT_THAT(consumption_log[0], Eq(production_log[0])); 
+}
+
+TEST_P(WithTwoOrMoreBuffers, consumer_cycles_through_all_available_buffers)
+{
+    auto tick = 0_t;
+    std::vector<ScheduleEntry> schedule;
+    for(auto i = 0; i < nbuffers; i++)
+        schedule.emplace_back(ScheduleEntry{tick++, {&producer}, {&consumer}});
+    run_system(schedule);
+
+    auto production_log = producer.production_log();
+    std::sort(production_log.begin(), production_log.end(),
+        [](BufferEntry const& a, BufferEntry const& b) { return a.id.as_value() > b.id.as_value(); });
+    auto it = std::unique(production_log.begin(), production_log.end());
+    production_log.erase(it, production_log.end());
+    EXPECT_THAT(production_log, SizeIs(nbuffers));
+}
+
+TEST_P(WithAnyNumberOfBuffers, compositor_can_always_get_a_buffer)
+{
+    std::vector<ScheduleEntry> schedule = {
+        {0_t, {&producer}, {}},
+        {1_t, {},          {&consumer}},
+        {2_t, {},          {&consumer}},
+        {3_t, {},          {&consumer}},
+        {5_t, {},          {&consumer}},
+        {6_t, {},          {&consumer}},
+    };
+    run_system(schedule);
+
+    auto consumption_log = consumer.consumption_log();
+    ASSERT_THAT(consumption_log, SizeIs(5));
+}
+
+TEST_P(WithTwoOrMoreBuffers, compositor_doesnt_starve_from_slow_client)
+{
+    std::vector<ScheduleEntry> schedule = {
+        {1_t,   {},          {&consumer}},
+        {60_t,  {},          {&consumer}},
+        {120_t, {},          {&consumer}},
+        {150_t, {&producer}, {}},
+        {180_t, {},          {&consumer}},
+        {240_t, {},          {&consumer}},
+        {270_t, {&producer}, {}},
+        {300_t, {},          {&consumer}},
+        {360_t, {},          {&consumer}},
+    };
+    run_system(schedule);
+
+    auto consumption_log = consumer.consumption_log();
+    ASSERT_THAT(consumption_log, SizeIs(7));
+    EXPECT_THAT(std::count(consumption_log.begin(), consumption_log.end(), consumption_log[0]), Eq(3));
+    EXPECT_THAT(std::count(consumption_log.begin(), consumption_log.end(), consumption_log[3]), Eq(2));
+    EXPECT_THAT(std::count(consumption_log.begin(), consumption_log.end(), consumption_log[5]), Eq(2));
+}
+
+TEST_P(WithTwoOrMoreBuffers, multiple_consumers_are_in_sync)
+{
+    std::vector<ScheduleEntry> schedule = {
+        {0_t,     {&producer}, {}},
+        {1_t,     {},          {&consumer}},
+        {60_t,    {},          {&consumer, &second_consumer}},
+        {119_t,   {},          {&consumer}},
+        {120_t,   {},          {&second_consumer}},
+        {130_t,   {&producer}, {}},
+        {178_t,   {},          {&consumer}},
+        {180_t,   {},          {&second_consumer}},
+        {237_t,   {},          {&consumer}},
+        {240_t,   {},          {&second_consumer}},
+    };
+    run_system(schedule);
+
+    auto production_log = producer.production_log();
+    auto consumption_log_1 = consumer.consumption_log();
+    auto consumption_log_2 = second_consumer.consumption_log();
+    ASSERT_THAT(consumption_log_1, SizeIs(5));
+    ASSERT_THAT(consumption_log_2, SizeIs(4));
+    ASSERT_THAT(production_log, SizeIs(2));
+
+    std::for_each(consumption_log_1.begin(), consumption_log_1.begin() + 3,
+        [&](BufferEntry const& entry){ EXPECT_THAT(entry, Eq(production_log[0])); });
+    std::for_each(consumption_log_1.begin() + 3, consumption_log_1.end(),
+        [&](BufferEntry const& entry){ EXPECT_THAT(entry, Eq(production_log[1])); });
+    std::for_each(consumption_log_2.begin(), consumption_log_2.begin() + 2,
+        [&](BufferEntry const& entry){ EXPECT_THAT(entry, Eq(production_log[0])); });
+    std::for_each(consumption_log_2.begin() + 2, consumption_log_2.end(),
+        [&](BufferEntry const& entry){ EXPECT_THAT(entry, Eq(production_log[1])); });
+}
+
+TEST_P(WithThreeOrMoreBuffers, multiple_fast_compositors_are_in_sync)
+{ 
+    std::vector<ScheduleEntry> schedule = {
+        {0_t,     {&producer}, {}},
+        {1_t,     {&producer}, {}},
+        {60_t,    {},          {&consumer, &second_consumer}},
+        {61_t,    {},          {&consumer, &second_consumer}},
+    };
+    run_system(schedule);
+
+    auto production_log = producer.production_log();
+    auto consumption_log_1 = consumer.consumption_log();
+    auto consumption_log_2 = second_consumer.consumption_log();
+    EXPECT_THAT(consumption_log_1, Eq(production_log));
+    EXPECT_THAT(consumption_log_2, Eq(production_log));
+}
+
+TEST_P(WithTwoOrMoreBuffers, framedropping_clients_get_all_buffers_and_dont_block)
+{
+    queue.allow_framedropping(true);
+    std::vector<ScheduleEntry> schedule;
+    for (auto i = 0; i < nbuffers * 3; i++)
+        schedule.emplace_back(ScheduleEntry{1_t, {&producer}, {}}); 
+    run_system(schedule);
+
+    auto production_log = producer.production_log();
+    std::sort(production_log.begin(), production_log.end(),
+        [](BufferEntry const& a, BufferEntry const& b) { return a.id.as_value() > b.id.as_value(); });
+    auto last = std::unique(production_log.begin(), production_log.end(),
+        [](BufferEntry const& a, BufferEntry const& b) { return a.id == b.id; });
+    production_log.erase(last, production_log.end());
+
+    EXPECT_THAT(production_log.size(), Ge(nbuffers)); //Ge is to accommodate overallocation
+}
+
+TEST_P(WithTwoOrMoreBuffers, nonframedropping_client_throttles_to_compositor_rate)
+{
+    unsigned int reps = 50;
+    auto const expected_blocks = reps - nbuffers;
+    std::vector<ScheduleEntry> schedule = {
+        {1_t,  {&producer, &producer}, {&consumer}},
+    };
+    repeat_system_until(schedule, [&reps]{ return --reps != 0; });
+
+    auto log = producer.production_log();
+    auto block_count = std::count_if(log.begin(), log.end(),
+        [](BufferEntry const& e) { return e.blockage == Access::blocked; });
+    EXPECT_THAT(block_count, Ge(expected_blocks));
+}
+
+TEST_P(WithAnyNumberOfBuffers, resize_affects_client_acquires_immediately)
+{
+    unsigned int const sizes_to_test{4};
+    geom::Size new_size = properties.size;
+    for(auto i = 0u; i < sizes_to_test; i++)
+    {
+        new_size = new_size * 2;
+        queue.resize(new_size);
+
+        std::vector<ScheduleEntry> schedule = {{1_t,  {&producer}, {&consumer}}};
+        run_system(schedule);
+        EXPECT_THAT(producer.last_size(), Eq(new_size));
+    }
+}
+
+TEST_P(WithAnyNumberOfBuffers, compositor_acquires_resized_frames)
+{
+    unsigned int const sizes_to_test{4};
+    int const attempt_limit{100};
+    geom::Size new_size = properties.size;
+    for(auto i = 0u; i < sizes_to_test; i++)
+    {
+        new_size = new_size * 2;
+        queue.resize(new_size);
+
+        std::vector<ScheduleEntry> schedule = {
+            {1_t,  {&producer}, {}},
+            {2_t,  {}, {&consumer}},
+            {3_t,  {&producer}, {}},
+        };
+        run_system(schedule);
+
+        int attempt_count = 0;
+        schedule = {{2_t,  {}, {&consumer}}};
+        repeat_system_until(schedule, [&] {
+            return (consumer.last_size() != new_size) && (attempt_count++ < attempt_limit); });
+
+        ASSERT_THAT(attempt_count, Lt(attempt_limit)) << "consumer never got the new size";
+    }
+}
+
+// Regression test for LP: #1396006
+TEST_P(WithTwoOrMoreBuffers, framedropping_policy_never_drops_newest_frame)
+{
+    mtd::MockFrameDroppingPolicyFactory policy_factory;
+    mc::BufferQueue queue{nbuffers, mt::fake_shared(server_buffer_factory), properties, policy_factory};
+    mc::BufferStreamSurfaces stream{mt::fake_shared(queue)};
+    BufferQueueProducer producer(stream);
+
+    for(auto i = 0; i < nbuffers; i++)
+        producer.produce();
+    policy_factory.trigger_policies();
+    producer.produce();
+
+    auto production_log = producer.production_log();
+    ASSERT_THAT(production_log, SizeIs(nbuffers + 1));
+    EXPECT_THAT(production_log[nbuffers], Not(Eq(production_log[nbuffers - 1]))); 
+}
+
+TEST_P(WithTwoOrMoreBuffers, uncomposited_client_swaps_when_policy_triggered)
+{
+    mtd::MockFrameDroppingPolicyFactory policy_factory;
+    mc::BufferQueue queue{nbuffers, mt::fake_shared(server_buffer_factory), properties, policy_factory};
+    mc::BufferStreamSurfaces stream{mt::fake_shared(queue)};
+    BufferQueueProducer producer(stream);
+
+    for(auto i = 0; i < nbuffers; i++)
+        producer.produce();
+    policy_factory.trigger_policies();
+    producer.produce();
+
+    auto production_log = producer.production_log();
+    ASSERT_THAT(production_log, SizeIs(nbuffers + 1));
+    EXPECT_THAT(production_log[nbuffers - 1].blockage, Eq(Access::blocked));
+    EXPECT_THAT(production_log[nbuffers].blockage, Eq(Access::unblocked));
+}
+
+// Regression test for LP: #1319765
+TEST_P(WithTwoBuffers, client_is_not_blocked_prematurely)
+{
+    producer.produce();
+    auto a = queue.compositor_acquire(this);
+    producer.produce();
+    auto b = queue.compositor_acquire(this);
+
+    ASSERT_NE(a.get(), b.get());
+
+    queue.compositor_release(a);
+    producer.produce();
+    queue.compositor_release(b);
+
+    /*
+     * Update to the original test case; This additional compositor acquire
+     * represents the fixing of LP: #1395581 in the compositor logic.
+     */
+    if (queue.buffers_ready_for_compositor(this))
+        queue.compositor_release(queue.compositor_acquire(this));
+
+    // With the fix, a buffer will be available instantaneously:
+    EXPECT_TRUE(producer.can_produce());
+}
+
+// Extended regression test for LP: #1319765
+TEST_P(WithTwoBuffers, composite_on_demand_never_deadlocks)
+{
+    for (int i = 0; i < 100; ++i)
+    {
+        producer.produce();
+        auto a = queue.compositor_acquire(this);
+        producer.produce();
+        auto b = queue.compositor_acquire(this);
+    
+        ASSERT_NE(a.get(), b.get());
+    
+        queue.compositor_release(a);
+        producer.produce();
+        queue.compositor_release(b);
+
+        /*
+         * Update to the original test case; This additional compositor acquire
+         * represents the fixing of LP: #1395581 in the compositor logic.
+         */
+        if (queue.buffers_ready_for_compositor(this))
+            queue.compositor_release(queue.compositor_acquire(this));
+
+        EXPECT_TRUE(producer.can_produce());
+
+        consumer.consume();
+        consumer.consume();
+    }
+}
+
+// Regression test for LP: #1395581
+TEST_P(WithTwoOrMoreBuffers, buffers_ready_is_not_underestimated)
+{
+    // Produce frame 1
+    producer.produce();
+    // Acquire frame 1
+    auto a = queue.compositor_acquire(this);
+
+    // Produce frame 2
+    producer.produce();
+    // Acquire frame 2
+    auto b = queue.compositor_acquire(this);
+
+    // Release frame 1
+    queue.compositor_release(a);
+    // Produce frame 3
+    producer.produce();
+    // Release frame 2
+    queue.compositor_release(b);
+
+    // Verify frame 3 is ready for the first compositor
+    EXPECT_THAT(queue.buffers_ready_for_compositor(this), Ge(1));
+    auto c = queue.compositor_acquire(this);
+
+    // Verify frame 3 is ready for a second compositor
+    int const other_compositor_id = 0;
+    ASSERT_THAT(queue.buffers_ready_for_compositor(&other_compositor_id), Ge(1));
+
+    queue.compositor_release(c);
+}
+
+TEST_P(WithTwoOrMoreBuffers, buffers_ready_eventually_reaches_zero)
+{
+    const int nmonitors = 3;
+    std::array<std::shared_ptr<BufferQueueConsumer>, nmonitors> consumers { {
+        std::make_shared<BufferQueueConsumer>(stream),
+        std::make_shared<BufferQueueConsumer>(stream),
+        std::make_shared<BufferQueueConsumer>(stream)
+    } };
+
+    for (auto const& consumer : consumers)
+        EXPECT_EQ(0, queue.buffers_ready_for_compositor(consumer.get()));
+
+    producer.produce();
+
+    for (auto const& consumer : consumers)
+    {
+        ASSERT_NE(0, queue.buffers_ready_for_compositor(consumer.get()));
+
+        // Double consume to account for the +1 that
+        // buffers_ready_for_compositor adds to do dynamic performance
+        // detection.
+        consumer->consume();
+        consumer->consume();
+
+        ASSERT_EQ(0, queue.buffers_ready_for_compositor(consumer.get()));
+    }
+}
+
+TEST_P(WithAnyNumberOfBuffers, compositor_inflates_ready_count_for_slow_clients)
+{
+    for (int frame = 0; frame < 10; frame++)
+    {
+        ASSERT_EQ(0, queue.buffers_ready_for_compositor(&consumer));
+        producer.produce();
+
+        // Detecting a slow client requires scheduling at least one extra
+        // frame...
+        int nready = queue.buffers_ready_for_compositor(&consumer);
+        ASSERT_EQ(2, nready);
+        for (int i = 0; i < nready; ++i)
+            consumer.consume();
+    }
+}
+
+TEST_P(WithAnyNumberOfBuffers, first_user_is_recorded)
+{
+    consumer.consume();
+    EXPECT_TRUE(queue.is_a_current_buffer_user(&consumer));
+}
+
+TEST_P(WithThreeBuffers, gives_compositor_a_valid_buffer_after_dropping_old_buffers_without_clients)
+{
+    queue.drop_old_buffers();
+    consumer.consume();
+    EXPECT_THAT(consumer.consumption_log(), SizeIs(1));
+}
+
+TEST_P(WithThreeBuffers, gives_new_compositor_the_newest_buffer_after_dropping_old_buffers)
+{
+    producer.produce();
+    consumer.consume();
+    producer.produce();
+    queue.drop_old_buffers();
+
+    void const* const new_compositor_id{&nbuffers};
+    auto comp2 = queue.compositor_acquire(new_compositor_id);
+
+    auto production_log = producer.production_log();
+    auto consumption_log = consumer.consumption_log();
+    ASSERT_THAT(production_log, SizeIs(2));
+    ASSERT_THAT(consumption_log, SizeIs(1));
+
+    EXPECT_THAT(production_log[0], Eq(consumption_log[0]));
+    EXPECT_THAT(production_log[1].id, Eq(comp2->id()));
+}
+
 int const max_buffers_to_test{5};
 INSTANTIATE_TEST_CASE_P(
     BufferScheduling,
@@ -254,3 +750,15 @@
     BufferScheduling,
     WithThreeOrMoreBuffers,
     Range(3, max_buffers_to_test));
+INSTANTIATE_TEST_CASE_P(
+    BufferScheduling,
+    WithOneBuffer,
+    Values(1));
+INSTANTIATE_TEST_CASE_P(
+    BufferScheduling,
+    WithTwoBuffers,
+    Values(2));
+INSTANTIATE_TEST_CASE_P(
+    BufferScheduling,
+    WithThreeBuffers,
+    Values(3));