← Back to branch summary

~mir-team/mir/fix-1339700-in-0.4

« back to all changes in this revision

Viewing changes to tests/unit-tests/compositor/test_occlusion.cpp

server: Track SceneElement visibility in the DefaultDisplayBufferCompositor.

Approved by PS Jenkins bot, Kevin DuBois, Alan Griffiths, Cemil Azizoglu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/compositor/test_occlusion.cpp
30
30
namespace mg = mir::graphics;
31
31
namespace mtd = mir::test::doubles;
32
32
 
 
33
namespace
 
34
{
33
35
struct OcclusionFilterTest : public Test
34
36
{
35
37
    OcclusionFilterTest()
48
50
        return elements;
49
51
    }
50
52
 
 
53
    mg::RenderableList renderables_from(SceneElementSequence const& elements)
 
54
    {
 
55
        mg::RenderableList renderables;
 
56
        for (auto const& element : elements)
 
57
            renderables.push_back(element->renderable());
 
58
 
 
59
        return renderables;
 
60
    }
 
61
 
51
62
    Rectangle monitor_rect;
52
63
};
53
64
 
 
65
}
 
66
 
54
67
TEST_F(OcclusionFilterTest, single_window_not_occluded)
55
68
{
56
69
    auto window = std::make_shared<mtd::FakeRenderable>(12, 34, 56, 78);
57
70
    auto elements = scene_elements_from({window});
58
71
 
59
 
    filter_occlusions_from(elements, monitor_rect);
60
 
    ASSERT_EQ(1u, elements.size());
61
 
    EXPECT_EQ(window, elements.front()->renderable());
 
72
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
 
73
 
 
74
    EXPECT_THAT(renderables_from(occlusions), IsEmpty());
 
75
    EXPECT_THAT(renderables_from(elements), ElementsAre(window));
62
76
}
63
77
 
64
78
TEST_F(OcclusionFilterTest, partially_offscreen_still_visible)
69
83
    auto bottom = std::make_shared<mtd::FakeRenderable>(200, 1000, 100, 1000);
70
84
    auto elements = scene_elements_from({left, right, top, bottom});
71
85
 
72
 
    filter_occlusions_from(elements, monitor_rect);
73
 
    EXPECT_EQ(4u, elements.size());
 
86
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
 
87
 
 
88
    EXPECT_THAT(renderables_from(occlusions), IsEmpty());
 
89
    EXPECT_THAT(renderables_from(elements), ElementsAre(left, right, top, bottom));
74
90
}
75
91
 
76
92
TEST_F(OcclusionFilterTest, smaller_window_occluded)
79
95
    auto bottom = std::make_shared<mtd::FakeRenderable>(12, 12, 5, 5);
80
96
    auto elements = scene_elements_from({bottom, top});
81
97
 
82
 
    filter_occlusions_from(elements, monitor_rect);
 
98
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
83
99
 
84
 
    ASSERT_EQ(1u, elements.size());
85
 
    EXPECT_EQ(top, elements.front()->renderable());
 
100
    EXPECT_THAT(renderables_from(occlusions), ElementsAre(bottom));
 
101
    EXPECT_THAT(renderables_from(elements), ElementsAre(top));
86
102
}
87
103
 
88
104
TEST_F(OcclusionFilterTest, translucent_window_occludes_nothing)
91
107
    auto bottom = std::make_shared<mtd::FakeRenderable>(Rectangle{{12, 12}, {5, 5}}, 1.0f);
92
108
    auto elements = scene_elements_from({bottom, top});
93
109
 
94
 
    filter_occlusions_from(elements, monitor_rect);
 
110
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
95
111
 
96
 
    ASSERT_EQ(2u, elements.size());
97
 
    EXPECT_EQ(bottom, elements.front()->renderable());
98
 
    EXPECT_EQ(top, elements.back()->renderable());
 
112
    EXPECT_THAT(renderables_from(occlusions), IsEmpty());
 
113
    EXPECT_THAT(renderables_from(elements), ElementsAre(bottom, top));
99
114
}
100
115
 
101
116
TEST_F(OcclusionFilterTest, hidden_window_is_self_occluded)
103
118
    auto window = std::make_shared<mtd::FakeRenderable>(Rectangle{{10, 10}, {10, 10}}, 1.0f, true, false);
104
119
    auto elements = scene_elements_from({window});
105
120
 
106
 
    filter_occlusions_from(elements, monitor_rect);
 
121
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
107
122
 
108
 
    EXPECT_EQ(0u, elements.size());
 
123
    EXPECT_THAT(renderables_from(occlusions), ElementsAre(window));
 
124
    EXPECT_THAT(renderables_from(elements), IsEmpty());
109
125
}
110
126
 
111
127
TEST_F(OcclusionFilterTest, hidden_window_occludes_nothing)
114
130
    auto bottom = std::make_shared<mtd::FakeRenderable>(12, 12, 5, 5);
115
131
    auto elements = scene_elements_from({bottom, top});
116
132
 
117
 
    filter_occlusions_from(elements, monitor_rect);
 
133
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
118
134
 
119
 
    ASSERT_EQ(1u, elements.size());
120
 
    EXPECT_EQ(bottom, elements.front()->renderable());
 
135
    EXPECT_THAT(renderables_from(occlusions), ElementsAre(top));
 
136
    EXPECT_THAT(renderables_from(elements), ElementsAre(bottom));
121
137
}
122
138
 
123
139
TEST_F(OcclusionFilterTest, shaped_window_occludes_nothing)
126
142
    auto bottom = std::make_shared<mtd::FakeRenderable>(12, 12, 5, 5);
127
143
    auto elements = scene_elements_from({bottom, top});
128
144
 
129
 
    filter_occlusions_from(elements, monitor_rect);
 
145
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
130
146
 
131
 
    ASSERT_EQ(2u, elements.size());
132
 
    EXPECT_EQ(bottom, elements.front()->renderable());
133
 
    EXPECT_EQ(top, elements.back()->renderable());
 
147
    EXPECT_THAT(renderables_from(occlusions), IsEmpty());
 
148
    EXPECT_THAT(renderables_from(elements), ElementsAre(bottom, top));
134
149
}
135
150
 
136
151
TEST_F(OcclusionFilterTest, identical_window_occluded)
139
154
    auto bottom = std::make_shared<mtd::FakeRenderable>(10, 10, 10, 10);
140
155
    auto elements = scene_elements_from({bottom, top});
141
156
 
142
 
    filter_occlusions_from(elements, monitor_rect);
 
157
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
143
158
 
144
 
    ASSERT_EQ(1u, elements.size());
145
 
    EXPECT_EQ(top, elements.front()->renderable());
 
159
    EXPECT_THAT(renderables_from(occlusions), ElementsAre(bottom));
 
160
    EXPECT_THAT(renderables_from(elements), ElementsAre(top));
146
161
}
147
162
 
148
163
TEST_F(OcclusionFilterTest, larger_window_never_occluded)
151
166
    auto bottom = std::make_shared<mtd::FakeRenderable>(9, 9, 12, 12);
152
167
    auto elements = scene_elements_from({bottom, top});
153
168
 
154
 
    filter_occlusions_from(elements, monitor_rect);
 
169
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
155
170
 
156
 
    ASSERT_EQ(2u, elements.size());
157
 
    EXPECT_EQ(bottom, elements.front()->renderable());
158
 
    EXPECT_EQ(top, elements.back()->renderable());
 
171
    EXPECT_THAT(renderables_from(occlusions), IsEmpty());
 
172
    EXPECT_THAT(renderables_from(elements), ElementsAre(bottom, top));
159
173
}
160
174
 
161
175
TEST_F(OcclusionFilterTest, cascaded_windows_never_occluded)
167
181
 
168
182
    auto elements = scene_elements_from(renderables);
169
183
 
170
 
    filter_occlusions_from(elements, monitor_rect);
171
 
    EXPECT_EQ(num_windows, elements.size());
 
184
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
 
185
 
 
186
    EXPECT_THAT(renderables_from(occlusions), IsEmpty());
 
187
    EXPECT_THAT(renderables_from(elements), ElementsAreArray(renderables));
172
188
}
173
189
 
174
190
TEST_F(OcclusionFilterTest, some_occluded_and_some_not)
188
204
        window0  //not occluded
189
205
    });
190
206
 
191
 
    filter_occlusions_from(elements, monitor_rect);
 
207
    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
192
208
 
193
 
    auto expected_size = 3u;
194
 
    ASSERT_EQ(expected_size, elements.size());
195
 
    auto it = elements.begin();
196
 
    for(auto count = 0u; count < expected_size; count++)
197
 
    {
198
 
        switch (count)
199
 
        {
200
 
            case 0u:
201
 
                EXPECT_EQ(window5, (*it)->renderable());
202
 
                break;
203
 
            case 1u:
204
 
                EXPECT_EQ(window4, (*it)->renderable());
205
 
                break;
206
 
            case 2u:
207
 
                EXPECT_EQ(window0, (*it)->renderable());
208
 
                break;
209
 
            default:
210
 
                FAIL();
211
 
                break;
212
 
        }
213
 
        it++;
214
 
    }
 
209
    EXPECT_THAT(renderables_from(occlusions), ElementsAre(window3, window2, window1));
 
210
    EXPECT_THAT(renderables_from(elements), ElementsAre(window5, window4, window0));
215
211
}