← Back to branch summary

~ubuntu-branches/ubuntu/wily/mir/wily-proposed

« back to all changes in this revision

Viewing changes to tests/unit-tests/graphics/android/test_hwc_configuration.cpp

  • Committer: Package Import Robot
  • Author(s): CI Train Bot
  • Date: 2015-05-12 13:12:55 UTC
  • mto: This revision was merged to the branch mainline in revision 96.
  • Revision ID: package-import@ubuntu.com-20150512131255-y7z12i8n4pbvo70x
Tags: upstream-0.13.0+15.10.20150512
Import upstream version 0.13.0+15.10.20150512

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/graphics/android/test_hwc_configuration.cpp
34
34
        std::make_shared<testing::NiceMock<mtd::MockHWCDeviceWrapper>>()};
35
35
    mga::DisplayName display{mga::DisplayName::primary};
36
36
    mga::HwcBlankingControl config{mock_hwc_wrapper};
 
37
    mga::HwcPowerModeControl power_mode_config{mock_hwc_wrapper};
37
38
};
38
39
 
39
40
TEST_F(HwcConfiguration, fb_format_selection)
68
69
        .InSequence(seq);
69
70
 
70
71
    mga::HwcBlankingControl hwc_config{mock_hwc_wrapper};
71
 
    EXPECT_EQ(mir_pixel_format_argb_8888, hwc_config.active_attribs_for(mga::DisplayName::primary).display_format);
 
72
    EXPECT_EQ(mir_pixel_format_argb_8888, hwc_config.active_config_for(mga::DisplayName::primary).current_format);
72
73
}
73
74
 
74
75
//not all hwc implementations give a hint about their framebuffer formats in their configuration.
92
93
        .InSequence(seq);
93
94
 
94
95
    mga::HwcBlankingControl hwc_config{mock_hwc_wrapper};
95
 
    EXPECT_EQ(mir_pixel_format_abgr_8888, hwc_config.active_attribs_for(mga::DisplayName::primary).display_format);
 
96
    EXPECT_EQ(mir_pixel_format_abgr_8888, hwc_config.active_config_for(mga::DisplayName::primary).current_format);
96
97
}
97
98
 
98
99
TEST_F(HwcConfiguration, turns_screen_on)
125
126
    config.power_mode(display, mir_power_mode_standby);
126
127
}
127
128
 
 
129
TEST_F(HwcConfiguration, translates_mir_power_mode_to_hwc_power_mode)
 
130
{
 
131
    testing::InSequence seq;
 
132
 
 
133
    EXPECT_CALL(*mock_hwc_wrapper, power_mode(display, mga::PowerMode::off));
 
134
    EXPECT_CALL(*mock_hwc_wrapper, power_mode(display, mga::PowerMode::doze_suspend));
 
135
    EXPECT_CALL(*mock_hwc_wrapper, power_mode(display, mga::PowerMode::doze));
 
136
    EXPECT_CALL(*mock_hwc_wrapper, power_mode(display, mga::PowerMode::normal));
 
137
 
 
138
    power_mode_config.power_mode(display, mir_power_mode_off);
 
139
    power_mode_config.power_mode(display, mir_power_mode_suspend);
 
140
    power_mode_config.power_mode(display, mir_power_mode_standby);
 
141
    power_mode_config.power_mode(display, mir_power_mode_on);
 
142
}
 
143
 
128
144
TEST_F(HwcConfiguration, queries_connected_primary_display_properties)
129
145
{
130
146
    using namespace testing;
169
185
                }
170
186
                //the attribute list should be at least this long, as some qcom drivers always deref attribute_list[5]
171
187
                EXPECT_EQ(5, i);
 
188
                return 0;
172
189
            }));
173
190
 
174
191
    auto vrefresh_hz = 1000.0 / vrefresh_period.count();
175
 
    auto attribs = config.active_attribs_for(display);
176
 
    EXPECT_THAT(attribs.pixel_size, Eq(px_size));
177
 
    EXPECT_THAT(attribs.mm_size, Eq(mm_size));
178
 
    EXPECT_THAT(attribs.vrefresh_hz, Eq(vrefresh_hz));
 
192
    auto attribs = config.active_config_for(display);
 
193
    ASSERT_THAT(attribs.modes.size(), Eq(1));
 
194
    EXPECT_THAT(attribs.modes[0].size, Eq(px_size));
 
195
    EXPECT_THAT(attribs.modes[0].vrefresh_hz, Eq(vrefresh_hz));
 
196
    EXPECT_THAT(attribs.physical_size_mm, Eq(mm_size));
179
197
    EXPECT_TRUE(attribs.connected);
 
198
    EXPECT_TRUE(attribs.used);
180
199
}
181
200
 
182
201
//the primary display should not be disconnected, but this is how to tell if the external one is
187
206
        .WillByDefault(Return(std::vector<mga::ConfigId>{}));
188
207
 
189
208
    EXPECT_THROW({
190
 
        config.active_attribs_for(mga::DisplayName::primary);
191
 
    }, std::runtime_error);
192
 
    auto external_attribs = config.active_attribs_for(mga::DisplayName::external);
193
 
    EXPECT_THAT(external_attribs.pixel_size, Eq(geom::Size{0,0}));
194
 
    EXPECT_THAT(external_attribs.vrefresh_hz, Eq(0.0));
195
 
    EXPECT_FALSE(external_attribs.connected);
 
209
        config.active_config_for(mga::DisplayName::primary);
 
210
    }, std::runtime_error);
 
211
    auto external_attribs = config.active_config_for(mga::DisplayName::external);
 
212
    EXPECT_THAT(external_attribs.modes.size(), Eq(0));
 
213
    EXPECT_FALSE(external_attribs.connected);
 
214
    EXPECT_FALSE(external_attribs.used);
 
215
}
 
216
 
 
217
//some devices (bq) only report an error later in the display attributes call, make sure to report disconnected on error to this call. 
 
218
TEST_F(HwcConfiguration, display_attributes_failure_indicates_problem_for_primary_disconnect_for_secondary)
 
219
{
 
220
    using namespace testing;
 
221
    ON_CALL(*mock_hwc_wrapper, display_attributes(_,_,_,_))
 
222
        .WillByDefault(Return(-22));
 
223
 
 
224
    EXPECT_THROW({
 
225
        config.active_config_for(mga::DisplayName::primary);
 
226
    }, std::runtime_error);
 
227
    auto external_attribs = config.active_config_for(mga::DisplayName::external);
 
228
    EXPECT_THAT(external_attribs.modes.size(), Eq(0));
 
229
    EXPECT_FALSE(external_attribs.connected);
 
230
    EXPECT_FALSE(external_attribs.used);
196
231
}
197
232
 
198
233
TEST_F(HwcConfiguration, no_fpe_from_malformed_refresh)
205
240
                int i = 0;
206
241
                while(attribute_list[i] != HWC_DISPLAY_NO_ATTRIBUTE)
207
242
                    values[i++] = 0;
 
243
                return 0;
208
244
            }));
209
 
    auto attribs = config.active_attribs_for(mga::DisplayName::external);
210
 
    EXPECT_THAT(attribs.vrefresh_hz, Eq(0.0f));
 
245
    auto attribs = config.active_config_for(mga::DisplayName::external);
 
246
    EXPECT_THAT(attribs.modes[attribs.current_mode_index].vrefresh_hz, Eq(0.0f));
211
247
}
212
248
 
213
249
TEST_F(HwcConfiguration, no_fpe_from_malformed_dpi)
220
256
                int i = 0;
221
257
                while(attribute_list[i] != HWC_DISPLAY_NO_ATTRIBUTE)
222
258
                    values[i++] = 0;
 
259
                return 0;
223
260
            }));
224
 
    auto attribs = config.active_attribs_for(mga::DisplayName::external);
225
 
    EXPECT_THAT(attribs.mm_size, Eq(geom::Size{0,0}));
 
261
    auto attribs = config.active_config_for(mga::DisplayName::external);
 
262
    EXPECT_THAT(attribs.physical_size_mm, Eq(geom::Size{0,0}));
 
263
}
 
264
 
 
265
TEST_F(HwcConfiguration, subscribes_to_hotplug_and_vsync)
 
266
{
 
267
    using namespace testing;
 
268
    std::function<void(mga::DisplayName, bool)> hotplug_fn([](mga::DisplayName, bool){});
 
269
    std::function<void(mga::DisplayName, std::chrono::nanoseconds)> vsync_fn(
 
270
        [](mga::DisplayName, std::chrono::nanoseconds){});
 
271
    EXPECT_CALL(*mock_hwc_wrapper, subscribe_to_events(_,_,_,_))
 
272
        .WillOnce(DoAll(SaveArg<1>(&vsync_fn), SaveArg<2>(&hotplug_fn)));
 
273
    EXPECT_CALL(*mock_hwc_wrapper, unsubscribe_from_events_(_));
 
274
 
 
275
    unsigned int hotplug_call_count{0};
 
276
    unsigned int vsync_call_count{0};
 
277
    auto subscription = config.subscribe_to_config_changes(
 
278
        [&]{ hotplug_call_count++; }, [&](mga::DisplayName){ vsync_call_count++; });
 
279
    hotplug_fn(mga::DisplayName::primary, true);
 
280
    hotplug_fn(mga::DisplayName::primary, true);
 
281
    vsync_fn(mga::DisplayName::primary, std::chrono::nanoseconds(33));
 
282
    EXPECT_THAT(hotplug_call_count, Eq(2));
 
283
    EXPECT_THAT(vsync_call_count, Eq(1));
 
284
}
 
285
 
 
286
TEST_F(HwcConfiguration, sets_active_config_when_needed)
 
287
{
 
288
    using namespace testing;
 
289
 
 
290
    std::vector<mga::ConfigId> config_ids{mga::ConfigId{0xA1}, mga::ConfigId{0xBEE}};
 
291
    mga::DisplayName display_name{mga::DisplayName::primary};
 
292
 
 
293
    EXPECT_CALL(*mock_hwc_wrapper, display_configs(display))
 
294
        .WillOnce(Return(config_ids));
 
295
    EXPECT_CALL(*mock_hwc_wrapper, has_active_config(display_name))
 
296
        .WillOnce(Return(false));
 
297
    EXPECT_CALL(*mock_hwc_wrapper, set_active_config(display_name, config_ids[0]));
 
298
 
 
299
    power_mode_config.active_config_for(display_name);
 
300
}
 
301
 
 
302
TEST_F(HwcConfiguration, uses_given_active_config_id)
 
303
{
 
304
    using namespace testing;
 
305
 
 
306
    std::vector<mga::ConfigId> config_ids{mga::ConfigId{0xA1}, mga::ConfigId{0xBEE}};
 
307
    mga::DisplayName display_name{mga::DisplayName::external};
 
308
 
 
309
    EXPECT_CALL(*mock_hwc_wrapper, display_configs(display_name))
 
310
        .WillOnce(Return(config_ids));
 
311
    EXPECT_CALL(*mock_hwc_wrapper, has_active_config(display_name))
 
312
        .WillOnce(Return(true));
 
313
    EXPECT_CALL(*mock_hwc_wrapper, active_config_for(display_name))
 
314
        .WillOnce(Return(config_ids[1]));
 
315
    EXPECT_CALL(*mock_hwc_wrapper, display_attributes(display_name, config_ids[1], _, _));
 
316
 
 
317
    power_mode_config.active_config_for(display_name);
226
318
}