1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <array>
18 #include <unordered_set>
19 #include <unordered_map>
20 #include <gtest/gtest.h>
21 #include <dlfcn.h>
22 #include <android-base/unique_fd.h>
23 #include <hardware/hardware.h>
24 #include <sync/sync.h>
25
26 #define HWC2_INCLUDE_STRINGIFICATION
27 #define HWC2_USE_CPP11
28 #include <hardware/hwcomposer2.h>
29 #undef HWC2_INCLUDE_STRINGIFICATION
30 #undef HWC2_USE_CPP11
31
32 #include "Hwc2TestLayer.h"
33 #include "Hwc2TestLayers.h"
34 #include "Hwc2TestClientTarget.h"
35 #include "Hwc2TestVirtualDisplay.h"
36
37 void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,
38 hwc2_display_t display, int32_t connected);
39 void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,
40 hwc2_display_t display, int64_t timestamp);
41
42 class Hwc2Test : public testing::Test {
43 public:
44
SetUp()45 virtual void SetUp()
46 {
47 hw_module_t const* hwc2Module;
48
49 int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &hwc2Module);
50 ASSERT_GE(err, 0) << "failed to get hwc hardware module: "
51 << strerror(-err);
52
53 /* The following method will fail if you have not run
54 * "adb shell stop" */
55 err = hwc2_open(hwc2Module, &mHwc2Device);
56 ASSERT_GE(err, 0) << "failed to open hwc hardware module: "
57 << strerror(-err);
58
59 populateDisplays();
60 }
61
TearDown()62 virtual void TearDown()
63 {
64
65 for (auto itr = mLayers.begin(); itr != mLayers.end();) {
66 hwc2_display_t display = itr->first;
67 hwc2_layer_t layer = itr->second;
68 itr++;
69 /* Destroys and removes the layer from mLayers */
70 destroyLayer(display, layer);
71 }
72
73 for (auto itr = mActiveDisplays.begin(); itr != mActiveDisplays.end();) {
74 hwc2_display_t display = *itr;
75 itr++;
76 /* Sets power mode to off and removes the display from
77 * mActiveDisplays */
78 setPowerMode(display, HWC2_POWER_MODE_OFF);
79 }
80
81 for (auto itr = mVirtualDisplays.begin(); itr != mVirtualDisplays.end();) {
82 hwc2_display_t display = *itr;
83 itr++;
84 /* Destroys virtual displays */
85 destroyVirtualDisplay(display);
86 }
87
88 if (mHwc2Device)
89 hwc2_close(mHwc2Device);
90 }
91
registerCallback(hwc2_callback_descriptor_t descriptor,hwc2_callback_data_t callbackData,hwc2_function_pointer_t pointer,hwc2_error_t * outErr=nullptr)92 void registerCallback(hwc2_callback_descriptor_t descriptor,
93 hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer,
94 hwc2_error_t* outErr = nullptr)
95 {
96 auto pfn = reinterpret_cast<HWC2_PFN_REGISTER_CALLBACK>(
97 getFunction(HWC2_FUNCTION_REGISTER_CALLBACK));
98 ASSERT_TRUE(pfn) << "failed to get function";
99
100 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, descriptor,
101 callbackData, pointer));
102 if (outErr) {
103 *outErr = err;
104 } else {
105 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to register callback";
106 }
107 }
108
getDisplayType(hwc2_display_t display,hwc2_display_type_t * outType,hwc2_error_t * outErr=nullptr)109 void getDisplayType(hwc2_display_t display, hwc2_display_type_t* outType,
110 hwc2_error_t* outErr = nullptr)
111 {
112 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_TYPE>(
113 getFunction(HWC2_FUNCTION_GET_DISPLAY_TYPE));
114 ASSERT_TRUE(pfn) << "failed to get function";
115
116 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
117 reinterpret_cast<int32_t*>(outType)));
118 if (outErr) {
119 *outErr = err;
120 } else {
121 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display type";
122 }
123 }
124
125 /* If the populateDisplays function is still receiving displays and the
126 * display is connected, the display handle is stored in mDisplays. */
hotplugCallback(hwc2_display_t display,int32_t connected)127 void hotplugCallback(hwc2_display_t display, int32_t connected)
128 {
129 std::lock_guard<std::mutex> lock(mHotplugMutex);
130
131 if (mHotplugStatus != Hwc2TestHotplugStatus::Receiving)
132 return;
133
134 if (connected == HWC2_CONNECTION_CONNECTED)
135 mDisplays.insert(display);
136
137 mHotplugCv.notify_all();
138 }
139
createLayer(hwc2_display_t display,hwc2_layer_t * outLayer,hwc2_error_t * outErr=nullptr)140 void createLayer(hwc2_display_t display, hwc2_layer_t* outLayer,
141 hwc2_error_t* outErr = nullptr)
142 {
143 auto pfn = reinterpret_cast<HWC2_PFN_CREATE_LAYER>(
144 getFunction(HWC2_FUNCTION_CREATE_LAYER));
145 ASSERT_TRUE(pfn) << "failed to get function";
146
147 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
148 outLayer));
149
150 if (err == HWC2_ERROR_NONE)
151 mLayers.insert(std::make_pair(display, *outLayer));
152
153 if (outErr) {
154 *outErr = err;
155 } else {
156 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer";
157 }
158 }
159
destroyLayer(hwc2_display_t display,hwc2_layer_t layer,hwc2_error_t * outErr=nullptr)160 void destroyLayer(hwc2_display_t display, hwc2_layer_t layer,
161 hwc2_error_t* outErr = nullptr)
162 {
163 auto pfn = reinterpret_cast<HWC2_PFN_DESTROY_LAYER>(
164 getFunction(HWC2_FUNCTION_DESTROY_LAYER));
165 ASSERT_TRUE(pfn) << "failed to get function";
166
167 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer));
168
169 if (err == HWC2_ERROR_NONE)
170 mLayers.erase(std::make_pair(display, layer));
171
172 if (outErr) {
173 *outErr = err;
174 } else {
175 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to destroy layer "
176 << layer;
177 }
178 }
179
getDisplayAttribute(hwc2_display_t display,hwc2_config_t config,hwc2_attribute_t attribute,int32_t * outValue,hwc2_error_t * outErr=nullptr)180 void getDisplayAttribute(hwc2_display_t display, hwc2_config_t config,
181 hwc2_attribute_t attribute, int32_t* outValue,
182 hwc2_error_t* outErr = nullptr)
183 {
184 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
185 getFunction(HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE));
186 ASSERT_TRUE(pfn) << "failed to get function";
187
188 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config,
189 attribute, outValue));
190
191 if (outErr) {
192 *outErr = err;
193 } else {
194 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display attribute "
195 << getAttributeName(attribute) << " for config " << config;
196 }
197 }
198
getDisplayConfigs(hwc2_display_t display,std::vector<hwc2_config_t> * outConfigs,hwc2_error_t * outErr=nullptr)199 void getDisplayConfigs(hwc2_display_t display,
200 std::vector<hwc2_config_t>* outConfigs,
201 hwc2_error_t* outErr = nullptr)
202 {
203 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_CONFIGS>(
204 getFunction(HWC2_FUNCTION_GET_DISPLAY_CONFIGS));
205 ASSERT_TRUE(pfn) << "failed to get function";
206
207 uint32_t numConfigs = 0;
208
209 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
210 &numConfigs, nullptr));
211
212 if (err == HWC2_ERROR_NONE) {
213 outConfigs->resize(numConfigs);
214
215 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
216 &numConfigs, outConfigs->data()));
217 }
218
219 if (outErr) {
220 *outErr = err;
221 } else {
222 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get configs for"
223 " display " << display;
224 }
225 }
226
getActiveConfig(hwc2_display_t display,hwc2_config_t * outConfig,hwc2_error_t * outErr=nullptr)227 void getActiveConfig(hwc2_display_t display, hwc2_config_t* outConfig,
228 hwc2_error_t* outErr = nullptr)
229 {
230 auto pfn = reinterpret_cast<HWC2_PFN_GET_ACTIVE_CONFIG>(
231 getFunction(HWC2_FUNCTION_GET_ACTIVE_CONFIG));
232 ASSERT_TRUE(pfn) << "failed to get function";
233
234 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
235 outConfig));
236 if (outErr) {
237 *outErr = err;
238 } else {
239 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get active config on"
240 " display " << display;
241 }
242 }
243
setActiveConfig(hwc2_display_t display,hwc2_config_t config,hwc2_error_t * outErr=nullptr)244 void setActiveConfig(hwc2_display_t display, hwc2_config_t config,
245 hwc2_error_t* outErr = nullptr)
246 {
247 auto pfn = reinterpret_cast<HWC2_PFN_SET_ACTIVE_CONFIG>(
248 getFunction(HWC2_FUNCTION_SET_ACTIVE_CONFIG));
249 ASSERT_TRUE(pfn) << "failed to get function";
250
251 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config));
252 if (outErr) {
253 *outErr = err;
254 } else {
255 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set active config "
256 << config;
257 }
258 }
259
getDozeSupport(hwc2_display_t display,int32_t * outSupport,hwc2_error_t * outErr=nullptr)260 void getDozeSupport(hwc2_display_t display, int32_t* outSupport,
261 hwc2_error_t* outErr = nullptr)
262 {
263 auto pfn = reinterpret_cast<HWC2_PFN_GET_DOZE_SUPPORT>(
264 getFunction(HWC2_FUNCTION_GET_DOZE_SUPPORT));
265 ASSERT_TRUE(pfn) << "failed to get function";
266
267 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
268 outSupport));
269 if (outErr) {
270 *outErr = err;
271 } else {
272 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get doze support on"
273 " display " << display;
274 }
275 }
276
setPowerMode(hwc2_display_t display,hwc2_power_mode_t mode,hwc2_error_t * outErr=nullptr)277 void setPowerMode(hwc2_display_t display, hwc2_power_mode_t mode,
278 hwc2_error_t* outErr = nullptr)
279 {
280 auto pfn = reinterpret_cast<HWC2_PFN_SET_POWER_MODE>(
281 getFunction(HWC2_FUNCTION_SET_POWER_MODE));
282 ASSERT_TRUE(pfn) << "failed to get function";
283
284 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
285 mode));
286 if (outErr) {
287 *outErr = err;
288 if (err != HWC2_ERROR_NONE)
289 return;
290 } else {
291 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set power mode "
292 << getPowerModeName(mode) << " on display " << display;
293 }
294
295 if (mode == HWC2_POWER_MODE_OFF) {
296 mActiveDisplays.erase(display);
297 } else {
298 mActiveDisplays.insert(display);
299 }
300 }
301
setVsyncEnabled(hwc2_display_t display,hwc2_vsync_t enabled,hwc2_error_t * outErr=nullptr)302 void setVsyncEnabled(hwc2_display_t display, hwc2_vsync_t enabled,
303 hwc2_error_t* outErr = nullptr)
304 {
305 auto pfn = reinterpret_cast<HWC2_PFN_SET_VSYNC_ENABLED>(
306 getFunction(HWC2_FUNCTION_SET_VSYNC_ENABLED));
307 ASSERT_TRUE(pfn) << "failed to get function";
308
309 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
310 enabled));
311 if (outErr) {
312 *outErr = err;
313 } else {
314 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set vsync enabled "
315 << getVsyncName(enabled);
316 }
317 }
318
vsyncCallback(hwc2_display_t display,int64_t timestamp)319 void vsyncCallback(hwc2_display_t display, int64_t timestamp)
320 {
321 std::lock_guard<std::mutex> lock(mVsyncMutex);
322 mVsyncDisplay = display;
323 mVsyncTimestamp = timestamp;
324 mVsyncCv.notify_all();
325 }
326
getDisplayName(hwc2_display_t display,std::string * outName,hwc2_error_t * outErr=nullptr)327 void getDisplayName(hwc2_display_t display, std::string* outName,
328 hwc2_error_t* outErr = nullptr)
329 {
330 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_NAME>(
331 getFunction(HWC2_FUNCTION_GET_DISPLAY_NAME));
332 ASSERT_TRUE(pfn) << "failed to get function";
333
334 uint32_t size = 0;
335
336 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size,
337 nullptr));
338
339 if (err == HWC2_ERROR_NONE) {
340 std::vector<char> name(size);
341
342 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size,
343 name.data()));
344
345 outName->assign(name.data());
346 }
347
348 if (outErr) {
349 *outErr = err;
350 } else {
351 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display name for "
352 << display;
353 }
354 }
355
setLayerCompositionType(hwc2_display_t display,hwc2_layer_t layer,hwc2_composition_t composition,hwc2_error_t * outErr=nullptr)356 void setLayerCompositionType(hwc2_display_t display, hwc2_layer_t layer,
357 hwc2_composition_t composition, hwc2_error_t* outErr = nullptr)
358 {
359 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
360 getFunction(HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE));
361 ASSERT_TRUE(pfn) << "failed to get function";
362
363 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
364 composition));
365 if (outErr) {
366 *outErr = err;
367 } else {
368 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer composition"
369 " type " << getCompositionName(composition);
370 }
371 }
372
setCursorPosition(hwc2_display_t display,hwc2_layer_t layer,int32_t x,int32_t y,hwc2_error_t * outErr=nullptr)373 void setCursorPosition(hwc2_display_t display, hwc2_layer_t layer,
374 int32_t x, int32_t y, hwc2_error_t* outErr = nullptr)
375 {
376 auto pfn = reinterpret_cast<HWC2_PFN_SET_CURSOR_POSITION>(
377 getFunction(HWC2_FUNCTION_SET_CURSOR_POSITION));
378 ASSERT_TRUE(pfn) << "failed to get function";
379
380 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer, x,
381 y));
382 if (outErr) {
383 *outErr = err;
384 } else {
385 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set cursor position";
386 }
387 }
388
setLayerBlendMode(hwc2_display_t display,hwc2_layer_t layer,hwc2_blend_mode_t mode,hwc2_error_t * outErr=nullptr)389 void setLayerBlendMode(hwc2_display_t display, hwc2_layer_t layer,
390 hwc2_blend_mode_t mode, hwc2_error_t* outErr = nullptr)
391 {
392 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BLEND_MODE>(
393 getFunction(HWC2_FUNCTION_SET_LAYER_BLEND_MODE));
394 ASSERT_TRUE(pfn) << "failed to get function";
395
396 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
397 mode));
398 if (outErr) {
399 *outErr = err;
400 } else {
401 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer blend mode "
402 << getBlendModeName(mode);
403 }
404 }
405
setLayerBuffer(hwc2_display_t display,hwc2_layer_t layer,buffer_handle_t buffer,int32_t acquireFence,hwc2_error_t * outErr=nullptr)406 void setLayerBuffer(hwc2_display_t display, hwc2_layer_t layer,
407 buffer_handle_t buffer, int32_t acquireFence,
408 hwc2_error_t* outErr = nullptr)
409 {
410 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BUFFER>(
411 getFunction(HWC2_FUNCTION_SET_LAYER_BUFFER));
412 ASSERT_TRUE(pfn) << "failed to get function";
413
414 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
415 buffer, acquireFence));
416 if (outErr) {
417 *outErr = err;
418 } else {
419 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer buffer";
420 }
421 }
422
setLayerColor(hwc2_display_t display,hwc2_layer_t layer,hwc_color_t color,hwc2_error_t * outErr=nullptr)423 void setLayerColor(hwc2_display_t display, hwc2_layer_t layer,
424 hwc_color_t color, hwc2_error_t* outErr = nullptr)
425 {
426 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COLOR>(
427 getFunction(HWC2_FUNCTION_SET_LAYER_COLOR));
428 ASSERT_TRUE(pfn) << "failed to get function";
429
430 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
431 color));
432 if (outErr) {
433 *outErr = err;
434 } else {
435 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer color";
436 }
437 }
438
setLayerDataspace(hwc2_display_t display,hwc2_layer_t layer,android_dataspace_t dataspace,hwc2_error_t * outErr=nullptr)439 void setLayerDataspace(hwc2_display_t display, hwc2_layer_t layer,
440 android_dataspace_t dataspace, hwc2_error_t* outErr = nullptr)
441 {
442 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DATASPACE>(
443 getFunction(HWC2_FUNCTION_SET_LAYER_DATASPACE));
444 ASSERT_TRUE(pfn) << "failed to get function";
445
446 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
447 layer, dataspace));
448 if (outErr) {
449 *outErr = err;
450 } else {
451 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer dataspace";
452 }
453 }
454
setLayerDisplayFrame(hwc2_display_t display,hwc2_layer_t layer,const hwc_rect_t & displayFrame,hwc2_error_t * outErr=nullptr)455 void setLayerDisplayFrame(hwc2_display_t display, hwc2_layer_t layer,
456 const hwc_rect_t& displayFrame, hwc2_error_t* outErr = nullptr)
457 {
458 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
459 getFunction(HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME));
460 ASSERT_TRUE(pfn) << "failed to get function";
461
462 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
463 displayFrame));
464 if (outErr) {
465 *outErr = err;
466 } else {
467 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer display"
468 " frame";
469 }
470 }
471
setLayerPlaneAlpha(hwc2_display_t display,hwc2_layer_t layer,float alpha,hwc2_error_t * outErr=nullptr)472 void setLayerPlaneAlpha(hwc2_display_t display, hwc2_layer_t layer,
473 float alpha, hwc2_error_t* outErr = nullptr)
474 {
475 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
476 getFunction(HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA));
477 ASSERT_TRUE(pfn) << "failed to get function";
478
479 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
480 alpha));
481 if (outErr) {
482 *outErr = err;
483 } else {
484 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer plane alpha "
485 << alpha;
486 }
487 }
488
setLayerSourceCrop(hwc2_display_t display,hwc2_layer_t layer,const hwc_frect_t & sourceCrop,hwc2_error_t * outErr=nullptr)489 void setLayerSourceCrop(hwc2_display_t display, hwc2_layer_t layer,
490 const hwc_frect_t& sourceCrop, hwc2_error_t* outErr = nullptr)
491 {
492 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
493 getFunction(HWC2_FUNCTION_SET_LAYER_SOURCE_CROP));
494 ASSERT_TRUE(pfn) << "failed to get function";
495
496 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
497 sourceCrop));
498 if (outErr) {
499 *outErr = err;
500 } else {
501 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer source crop";
502 }
503 }
504
setLayerSurfaceDamage(hwc2_display_t display,hwc2_layer_t layer,const hwc_region_t & surfaceDamage,hwc2_error_t * outErr=nullptr)505 void setLayerSurfaceDamage(hwc2_display_t display, hwc2_layer_t layer,
506 const hwc_region_t& surfaceDamage, hwc2_error_t* outErr = nullptr)
507 {
508 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
509 getFunction(HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE));
510 ASSERT_TRUE(pfn) << "failed to get function";
511
512 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
513 surfaceDamage));
514 if (outErr) {
515 *outErr = err;
516 } else {
517 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer surface"
518 " damage";
519 }
520 }
521
setLayerTransform(hwc2_display_t display,hwc2_layer_t layer,hwc_transform_t transform,hwc2_error_t * outErr=nullptr)522 void setLayerTransform(hwc2_display_t display, hwc2_layer_t layer,
523 hwc_transform_t transform, hwc2_error_t* outErr = nullptr)
524 {
525 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_TRANSFORM>(
526 getFunction(HWC2_FUNCTION_SET_LAYER_TRANSFORM));
527 ASSERT_TRUE(pfn) << "failed to get function";
528
529 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
530 transform));
531 if (outErr) {
532 *outErr = err;
533 } else {
534 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer transform "
535 << getTransformName(transform);
536 }
537 }
538
setLayerVisibleRegion(hwc2_display_t display,hwc2_layer_t layer,const hwc_region_t & visibleRegion,hwc2_error_t * outErr=nullptr)539 void setLayerVisibleRegion(hwc2_display_t display, hwc2_layer_t layer,
540 const hwc_region_t& visibleRegion, hwc2_error_t* outErr = nullptr)
541 {
542 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
543 getFunction(HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION));
544 ASSERT_TRUE(pfn) << "failed to get function";
545
546 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
547 visibleRegion));
548 if (outErr) {
549 *outErr = err;
550 } else {
551 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer visible"
552 " region";
553 }
554 }
555
setLayerZOrder(hwc2_display_t display,hwc2_layer_t layer,uint32_t zOrder,hwc2_error_t * outErr=nullptr)556 void setLayerZOrder(hwc2_display_t display, hwc2_layer_t layer,
557 uint32_t zOrder, hwc2_error_t* outErr = nullptr)
558 {
559 auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_Z_ORDER>(
560 getFunction(HWC2_FUNCTION_SET_LAYER_Z_ORDER));
561 ASSERT_TRUE(pfn) << "failed to get function";
562
563 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
564 zOrder));
565 if (outErr) {
566 *outErr = err;
567 } else {
568 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer z order "
569 << zOrder;
570 }
571 }
572
validateDisplay(hwc2_display_t display,uint32_t * outNumTypes,uint32_t * outNumRequests,hwc2_error_t * outErr)573 void validateDisplay(hwc2_display_t display, uint32_t* outNumTypes,
574 uint32_t* outNumRequests, hwc2_error_t* outErr)
575 {
576 auto pfn = reinterpret_cast<HWC2_PFN_VALIDATE_DISPLAY>(
577 getFunction(HWC2_FUNCTION_VALIDATE_DISPLAY));
578 ASSERT_TRUE(pfn) << "failed to get function";
579
580 *outErr = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
581 outNumTypes, outNumRequests));
582 }
583
validateDisplay(hwc2_display_t display,uint32_t * outNumTypes,uint32_t * outNumRequests,bool * outHasChanges)584 void validateDisplay(hwc2_display_t display, uint32_t* outNumTypes,
585 uint32_t* outNumRequests, bool* outHasChanges)
586 {
587 hwc2_error_t err = HWC2_ERROR_NONE;
588
589 EXPECT_NO_FATAL_FAILURE(validateDisplay(display, outNumTypes,
590 outNumRequests, &err));
591
592 if (err != HWC2_ERROR_HAS_CHANGES) {
593 *outHasChanges = false;
594 EXPECT_EQ(err, HWC2_ERROR_NONE) << "failed to validate display";
595 } else {
596 *outHasChanges = true;
597 }
598 }
599
getDisplayRequests(hwc2_display_t display,hwc2_display_request_t * outDisplayRequests,std::vector<hwc2_layer_t> * outLayers,std::vector<hwc2_layer_request_t> * outLayerRequests,hwc2_error_t * outErr=nullptr)600 void getDisplayRequests(hwc2_display_t display,
601 hwc2_display_request_t* outDisplayRequests,
602 std::vector<hwc2_layer_t>* outLayers,
603 std::vector<hwc2_layer_request_t>* outLayerRequests,
604 hwc2_error_t* outErr = nullptr)
605 {
606 auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_REQUESTS>(
607 getFunction(HWC2_FUNCTION_GET_DISPLAY_REQUESTS));
608 ASSERT_TRUE(pfn) << "failed to get function";
609
610 uint32_t numElements = 0;
611
612 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
613 reinterpret_cast<int32_t*>(outDisplayRequests), &numElements,
614 nullptr, nullptr));
615
616 if (err == HWC2_ERROR_NONE && numElements > 0) {
617 outLayers->resize(numElements);
618 outLayerRequests->resize(numElements);
619
620 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
621 reinterpret_cast<int32_t*>(outDisplayRequests), &numElements,
622 reinterpret_cast<uint64_t*>(outLayers->data()),
623 reinterpret_cast<int32_t*>(outLayerRequests->data())));
624 }
625
626 if (outErr) {
627 *outErr = err;
628 } else {
629 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display requests";
630 }
631 }
632
handleRequests(hwc2_display_t display,const std::vector<hwc2_layer_t> & layers,uint32_t numRequests,std::set<hwc2_layer_t> * outClearLayers=nullptr,bool * outFlipClientTarget=nullptr)633 void handleRequests(hwc2_display_t display,
634 const std::vector<hwc2_layer_t>& layers, uint32_t numRequests,
635 std::set<hwc2_layer_t>* outClearLayers = nullptr,
636 bool* outFlipClientTarget = nullptr)
637 {
638 hwc2_display_request_t displayRequest =
639 static_cast<hwc2_display_request_t>(0);
640 std::vector<hwc2_layer_t> requestedLayers;
641 std::vector<hwc2_layer_request_t> requests;
642
643 ASSERT_NO_FATAL_FAILURE(getDisplayRequests(display, &displayRequest,
644 &requestedLayers, &requests));
645
646 EXPECT_EQ(numRequests, requests.size()) << "validate returned "
647 << numRequests << " requests and get display requests returned "
648 << requests.size() << " requests";
649
650 for (size_t i = 0; i < requests.size(); i++) {
651 hwc2_layer_t requestedLayer = requestedLayers.at(i);
652 hwc2_layer_request_t request = requests.at(i);
653
654 EXPECT_EQ(std::count(layers.begin(), layers.end(), requestedLayer),
655 0) << "get display requests returned an unknown layer";
656 EXPECT_NE(request, 0) << "returned empty request for layer "
657 << requestedLayer;
658
659 if (outClearLayers && request
660 == HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET)
661 outClearLayers->insert(requestedLayer);
662 }
663
664 if (outFlipClientTarget)
665 *outFlipClientTarget = displayRequest
666 & HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET;
667 }
668
getChangedCompositionTypes(hwc2_display_t display,std::vector<hwc2_layer_t> * outLayers,std::vector<hwc2_composition_t> * outTypes,hwc2_error_t * outErr=nullptr)669 void getChangedCompositionTypes(hwc2_display_t display,
670 std::vector<hwc2_layer_t>* outLayers,
671 std::vector<hwc2_composition_t>* outTypes,
672 hwc2_error_t* outErr = nullptr)
673 {
674 auto pfn = reinterpret_cast<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
675 getFunction(HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES));
676 ASSERT_TRUE(pfn) << "failed to get function";
677
678 uint32_t numElements = 0;
679
680 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
681 &numElements, nullptr, nullptr));
682
683 if (err == HWC2_ERROR_NONE && numElements > 0) {
684 outLayers->resize(numElements);
685 outTypes->resize(numElements);
686
687 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
688 &numElements, reinterpret_cast<uint64_t*>(outLayers->data()),
689 reinterpret_cast<int32_t*>(outTypes->data())));
690 }
691
692 if (outErr) {
693 *outErr = err;
694 } else {
695 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get changed"
696 " composition types";
697 }
698 }
699
handleCompositionChanges(hwc2_display_t display,const Hwc2TestLayers & testLayers,const std::vector<hwc2_layer_t> & layers,uint32_t numTypes,std::set<hwc2_layer_t> * outClientLayers=nullptr)700 void handleCompositionChanges(hwc2_display_t display,
701 const Hwc2TestLayers& testLayers,
702 const std::vector<hwc2_layer_t>& layers, uint32_t numTypes,
703 std::set<hwc2_layer_t>* outClientLayers = nullptr)
704 {
705 std::vector<hwc2_layer_t> changedLayers;
706 std::vector<hwc2_composition_t> types;
707
708 ASSERT_NO_FATAL_FAILURE(getChangedCompositionTypes(display,
709 &changedLayers, &types));
710
711 EXPECT_EQ(numTypes, types.size()) << "validate returned "
712 << numTypes << " types and get changed composition types"
713 " returned " << types.size() << " types";
714
715 for (size_t i = 0; i < types.size(); i++) {
716
717 auto layer = std::find(layers.begin(), layers.end(),
718 changedLayers.at(i));
719
720 EXPECT_TRUE(layer != layers.end() || !testLayers.contains(*layer))
721 << "get changed composition types returned an unknown layer";
722
723 hwc2_composition_t requestedType = testLayers.getComposition(*layer);
724 hwc2_composition_t returnedType = types.at(i);
725
726 EXPECT_NE(returnedType, HWC2_COMPOSITION_INVALID) << "get changed"
727 " composition types returned invalid composition";
728
729 switch (requestedType) {
730 case HWC2_COMPOSITION_CLIENT:
731 EXPECT_TRUE(false) << getCompositionName(returnedType)
732 << " cannot be changed";
733 break;
734 case HWC2_COMPOSITION_DEVICE:
735 case HWC2_COMPOSITION_SOLID_COLOR:
736 EXPECT_EQ(returnedType, HWC2_COMPOSITION_CLIENT)
737 << "composition of type "
738 << getCompositionName(requestedType)
739 << " can only be changed to "
740 << getCompositionName(HWC2_COMPOSITION_CLIENT);
741 break;
742 case HWC2_COMPOSITION_CURSOR:
743 case HWC2_COMPOSITION_SIDEBAND:
744 EXPECT_TRUE(returnedType == HWC2_COMPOSITION_CLIENT
745 || returnedType == HWC2_COMPOSITION_DEVICE)
746 << "composition of type "
747 << getCompositionName(requestedType)
748 << " can only be changed to "
749 << getCompositionName(HWC2_COMPOSITION_CLIENT) << " or "
750 << getCompositionName(HWC2_COMPOSITION_DEVICE);
751 break;
752 default:
753 EXPECT_TRUE(false) << "unknown type "
754 << getCompositionName(requestedType);
755 break;
756 }
757
758 if (outClientLayers)
759 if (returnedType == HWC2_COMPOSITION_CLIENT)
760 outClientLayers->insert(*layer);
761 }
762
763 if (outClientLayers) {
764 for (auto layer : layers) {
765 if (testLayers.getComposition(layer) == HWC2_COMPOSITION_CLIENT)
766 outClientLayers->insert(layer);
767 }
768 }
769 }
770
acceptDisplayChanges(hwc2_display_t display,hwc2_error_t * outErr=nullptr)771 void acceptDisplayChanges(hwc2_display_t display,
772 hwc2_error_t* outErr = nullptr)
773 {
774 auto pfn = reinterpret_cast<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
775 getFunction(HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES));
776 ASSERT_TRUE(pfn) << "failed to get function";
777
778 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display));
779 if (outErr) {
780 *outErr = err;
781 } else {
782 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to accept display changes";
783 }
784 }
785
getClientTargetSupport(hwc2_display_t display,int32_t width,int32_t height,android_pixel_format_t format,android_dataspace_t dataspace,hwc2_error_t * outErr=nullptr)786 void getClientTargetSupport(hwc2_display_t display, int32_t width,
787 int32_t height, android_pixel_format_t format,
788 android_dataspace_t dataspace, hwc2_error_t* outErr = nullptr)
789 {
790 auto pfn = reinterpret_cast<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
791 getFunction(HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT));
792 ASSERT_TRUE(pfn) << "failed to get function";
793
794 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, width,
795 height, format, dataspace));
796 if (outErr) {
797 *outErr = err;
798 } else {
799 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get client target"
800 " support";
801 }
802 }
803
setClientTarget(hwc2_display_t display,buffer_handle_t handle,int32_t acquireFence,android_dataspace_t dataspace,hwc_region_t damage,hwc2_error_t * outErr=nullptr)804 void setClientTarget(hwc2_display_t display, buffer_handle_t handle,
805 int32_t acquireFence, android_dataspace_t dataspace,
806 hwc_region_t damage, hwc2_error_t* outErr = nullptr)
807 {
808 auto pfn = reinterpret_cast<HWC2_PFN_SET_CLIENT_TARGET>(
809 getFunction(HWC2_FUNCTION_SET_CLIENT_TARGET));
810 ASSERT_TRUE(pfn) << "failed to get function";
811
812 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, handle,
813 acquireFence, dataspace, damage));
814 if (outErr) {
815 *outErr = err;
816 } else {
817 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set client target";
818 }
819 }
820
presentDisplay(hwc2_display_t display,int32_t * outPresentFence,hwc2_error_t * outErr=nullptr)821 void presentDisplay(hwc2_display_t display, int32_t* outPresentFence,
822 hwc2_error_t* outErr = nullptr)
823 {
824 auto pfn = reinterpret_cast<HWC2_PFN_PRESENT_DISPLAY>(
825 getFunction(HWC2_FUNCTION_PRESENT_DISPLAY));
826 ASSERT_TRUE(pfn) << "failed to get function";
827
828 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
829 outPresentFence));
830 if (outErr) {
831 *outErr = err;
832 } else {
833 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to present display";
834 }
835 }
836
getReleaseFences(hwc2_display_t display,std::vector<hwc2_layer_t> * outLayers,std::vector<int32_t> * outFences,hwc2_error_t * outErr=nullptr)837 void getReleaseFences(hwc2_display_t display,
838 std::vector<hwc2_layer_t>* outLayers,
839 std::vector<int32_t>* outFences, hwc2_error_t* outErr = nullptr)
840 {
841 auto pfn = reinterpret_cast<HWC2_PFN_GET_RELEASE_FENCES>(
842 getFunction(HWC2_FUNCTION_GET_RELEASE_FENCES));
843 ASSERT_TRUE(pfn) << "failed to get function";
844
845 uint32_t numElements = 0;
846
847 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
848 &numElements, nullptr, nullptr));
849
850 if (err == HWC2_ERROR_NONE) {
851 outLayers->resize(numElements);
852 outFences->resize(numElements);
853
854 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
855 &numElements, outLayers->data(), outFences->data()));
856 }
857
858 if (outErr) {
859 *outErr = err;
860 } else {
861 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get release fences";
862 }
863 }
864
getColorModes(hwc2_display_t display,std::vector<android_color_mode_t> * outColorModes,hwc2_error_t * outErr=nullptr)865 void getColorModes(hwc2_display_t display,
866 std::vector<android_color_mode_t>* outColorModes,
867 hwc2_error_t* outErr = nullptr)
868 {
869 auto pfn = reinterpret_cast<HWC2_PFN_GET_COLOR_MODES>(
870 getFunction(HWC2_FUNCTION_GET_COLOR_MODES));
871 ASSERT_TRUE(pfn) << "failed to get function";
872
873 uint32_t numColorModes = 0;
874
875 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
876 &numColorModes, nullptr));
877 if (err == HWC2_ERROR_NONE) {
878 outColorModes->resize(numColorModes);
879
880 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
881 &numColorModes,
882 reinterpret_cast<int32_t*>(outColorModes->data())));
883 }
884
885 if (outErr) {
886 *outErr = err;
887 } else {
888 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get color modes for"
889 " display " << display;
890 }
891 }
892
setColorMode(hwc2_display_t display,android_color_mode_t colorMode,hwc2_error_t * outErr=nullptr)893 void setColorMode(hwc2_display_t display, android_color_mode_t colorMode,
894 hwc2_error_t* outErr = nullptr)
895 {
896 auto pfn = reinterpret_cast<HWC2_PFN_SET_COLOR_MODE>(
897 getFunction(HWC2_FUNCTION_SET_COLOR_MODE));
898 ASSERT_TRUE(pfn) << "failed to get function";
899
900 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
901 static_cast<int32_t>(colorMode)));
902 if (outErr) {
903 *outErr = err;
904 } else {
905 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set color mode "
906 << colorMode;
907 }
908 }
909
getHdrCapabilities(hwc2_display_t display,std::vector<android_hdr_t> * outTypes,float * outMaxLuminance,float * outMaxAverageLuminance,float * outMinLuminance,hwc2_error_t * outErr=nullptr)910 void getHdrCapabilities(hwc2_display_t display,
911 std::vector<android_hdr_t>* outTypes, float* outMaxLuminance,
912 float* outMaxAverageLuminance, float* outMinLuminance,
913 hwc2_error_t* outErr = nullptr)
914 {
915 auto pfn = reinterpret_cast<HWC2_PFN_GET_HDR_CAPABILITIES>(
916 getFunction(HWC2_FUNCTION_GET_HDR_CAPABILITIES));
917 ASSERT_TRUE(pfn) << "failed to get function";
918
919 uint32_t numTypes = 0;
920
921 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
922 &numTypes, nullptr, outMaxLuminance, outMaxAverageLuminance,
923 outMinLuminance));
924
925 if (err == HWC2_ERROR_NONE) {
926 outTypes->resize(numTypes);
927
928 err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &numTypes,
929 reinterpret_cast<int32_t*>(outTypes->data()), outMaxLuminance,
930 outMaxAverageLuminance, outMinLuminance));
931 }
932
933 if (outErr) {
934 *outErr = err;
935 } else {
936 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get hdr capabilities"
937 " for display " << display;
938 }
939 }
940
setColorTransform(hwc2_display_t display,const std::array<float,16> & matrix,android_color_transform_t hint,hwc2_error_t * outErr=nullptr)941 void setColorTransform(hwc2_display_t display,
942 const std::array<float, 16>& matrix, android_color_transform_t hint,
943 hwc2_error_t* outErr = nullptr)
944 {
945 auto pfn = reinterpret_cast<HWC2_PFN_SET_COLOR_TRANSFORM>(
946 getFunction(HWC2_FUNCTION_SET_COLOR_TRANSFORM));
947 ASSERT_TRUE(pfn) << "failed to get function";
948
949 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
950 matrix.data(), hint));
951
952 if (outErr) {
953 *outErr = err;
954 } else {
955 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set color transform "
956 << hint;
957 }
958 }
959
createVirtualDisplay(uint32_t width,uint32_t height,android_pixel_format_t * outFormat,hwc2_display_t * outDisplay,hwc2_error_t * outErr=nullptr)960 void createVirtualDisplay(uint32_t width, uint32_t height,
961 android_pixel_format_t* outFormat, hwc2_display_t* outDisplay,
962 hwc2_error_t* outErr = nullptr)
963 {
964 auto pfn = reinterpret_cast<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
965 getFunction(HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY));
966 ASSERT_TRUE(pfn) << "failed to get function";
967
968 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, width, height,
969 reinterpret_cast<int32_t*>(outFormat), outDisplay));
970
971 if (err == HWC2_ERROR_NONE)
972 mVirtualDisplays.insert(*outDisplay);
973
974 if (outErr) {
975 *outErr = err;
976 } else {
977 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create virtual display";
978 }
979 }
980
destroyVirtualDisplay(hwc2_display_t display,hwc2_error_t * outErr=nullptr)981 void destroyVirtualDisplay(hwc2_display_t display,
982 hwc2_error_t* outErr = nullptr)
983 {
984 auto pfn = reinterpret_cast<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
985 getFunction(HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY));
986 ASSERT_TRUE(pfn) << "failed to get function";
987
988 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display));
989
990 if (err == HWC2_ERROR_NONE)
991 mVirtualDisplays.erase(display);
992
993 if (outErr) {
994 *outErr = err;
995 } else {
996 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to destroy virtual display";
997 }
998 }
999
getMaxVirtualDisplayCount(uint32_t * outMaxCnt)1000 void getMaxVirtualDisplayCount(uint32_t* outMaxCnt)
1001 {
1002 auto pfn = reinterpret_cast<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
1003 getFunction(HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT));
1004 ASSERT_TRUE(pfn) << "failed to get function";
1005
1006 *outMaxCnt = pfn(mHwc2Device);
1007 }
1008
setOutputBuffer(hwc2_display_t display,buffer_handle_t buffer,int32_t releaseFence,hwc2_error_t * outErr=nullptr)1009 void setOutputBuffer(hwc2_display_t display, buffer_handle_t buffer,
1010 int32_t releaseFence, hwc2_error_t* outErr = nullptr)
1011 {
1012 auto pfn = reinterpret_cast<HWC2_PFN_SET_OUTPUT_BUFFER>(
1013 getFunction(HWC2_FUNCTION_SET_OUTPUT_BUFFER));
1014 ASSERT_TRUE(pfn) << "failed to get function";
1015
1016 auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, buffer,
1017 releaseFence));
1018 if (outErr) {
1019 *outErr = err;
1020 } else {
1021 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set output buffer";
1022 }
1023 }
1024
dump(std::string * outBuffer)1025 void dump(std::string* outBuffer)
1026 {
1027 auto pfn = reinterpret_cast<HWC2_PFN_DUMP>(
1028 getFunction(HWC2_FUNCTION_DUMP));
1029 ASSERT_TRUE(pfn) << "failed to get function";
1030
1031 uint32_t size = 0;
1032
1033 pfn(mHwc2Device, &size, nullptr);
1034
1035 std::vector<char> buffer(size);
1036
1037 pfn(mHwc2Device, &size, buffer.data());
1038
1039 outBuffer->assign(buffer.data());
1040 }
1041
getBadDisplay(hwc2_display_t * outDisplay)1042 void getBadDisplay(hwc2_display_t* outDisplay)
1043 {
1044 for (hwc2_display_t display = 0; display < UINT64_MAX; display++) {
1045 if (mDisplays.count(display) == 0) {
1046 *outDisplay = display;
1047 return;
1048 }
1049 }
1050 ASSERT_TRUE(false) << "Unable to find bad display. UINT64_MAX displays"
1051 " are registered. This should never happen.";
1052 }
1053
waitForVsync(hwc2_display_t * outDisplay=nullptr,int64_t * outTimestamp=nullptr)1054 void waitForVsync(hwc2_display_t* outDisplay = nullptr,
1055 int64_t* outTimestamp = nullptr)
1056 {
1057 std::unique_lock<std::mutex> lock(mVsyncMutex);
1058 ASSERT_EQ(mVsyncCv.wait_for(lock, std::chrono::seconds(3)),
1059 std::cv_status::no_timeout) << "timed out attempting to get"
1060 " vsync callback";
1061 if (outDisplay)
1062 *outDisplay = mVsyncDisplay;
1063 if (outTimestamp)
1064 *outTimestamp = mVsyncTimestamp;
1065 }
1066
enableVsync(hwc2_display_t display)1067 void enableVsync(hwc2_display_t display)
1068 {
1069 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, this,
1070 reinterpret_cast<hwc2_function_pointer_t>(
1071 hwc2TestVsyncCallback)));
1072 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
1073 }
1074
disableVsync(hwc2_display_t display)1075 void disableVsync(hwc2_display_t display)
1076 {
1077 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1078 }
1079
1080 protected:
getFunction(hwc2_function_descriptor_t descriptor)1081 hwc2_function_pointer_t getFunction(hwc2_function_descriptor_t descriptor)
1082 {
1083 return mHwc2Device->getFunction(mHwc2Device, descriptor);
1084 }
1085
getCapabilities(std::vector<hwc2_capability_t> * outCapabilities)1086 void getCapabilities(std::vector<hwc2_capability_t>* outCapabilities)
1087 {
1088 uint32_t num = 0;
1089
1090 mHwc2Device->getCapabilities(mHwc2Device, &num, nullptr);
1091
1092 outCapabilities->resize(num);
1093
1094 mHwc2Device->getCapabilities(mHwc2Device, &num,
1095 reinterpret_cast<int32_t*>(outCapabilities->data()));
1096 }
1097
1098 /* Registers a hotplug callback and waits for hotplug callbacks. This
1099 * function will have no effect if called more than once. */
populateDisplays()1100 void populateDisplays()
1101 {
1102 /* Sets the hotplug status to receiving */
1103 {
1104 std::lock_guard<std::mutex> lock(mHotplugMutex);
1105
1106 if (mHotplugStatus != Hwc2TestHotplugStatus::Init)
1107 return;
1108 mHotplugStatus = Hwc2TestHotplugStatus::Receiving;
1109 }
1110
1111 /* Registers the callback. This function call cannot be locked because
1112 * a callback could happen on the same thread */
1113 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_HOTPLUG, this,
1114 reinterpret_cast<hwc2_function_pointer_t>(
1115 hwc2TestHotplugCallback)));
1116
1117 /* Waits for hotplug events. If a hotplug event has not come within 1
1118 * second, stop waiting. */
1119 std::unique_lock<std::mutex> lock(mHotplugMutex);
1120
1121 while (mHotplugCv.wait_for(lock, std::chrono::seconds(1)) !=
1122 std::cv_status::timeout) { }
1123
1124 /* Sets the hotplug status to done. Future calls will have no effect */
1125 mHotplugStatus = Hwc2TestHotplugStatus::Done;
1126 }
1127
1128 /* NOTE: will create min(newlayerCnt, max supported layers) layers */
createLayers(hwc2_display_t display,std::vector<hwc2_layer_t> * outLayers,size_t newLayerCnt)1129 void createLayers(hwc2_display_t display,
1130 std::vector<hwc2_layer_t>* outLayers, size_t newLayerCnt)
1131 {
1132 std::vector<hwc2_layer_t> newLayers;
1133 hwc2_layer_t layer;
1134 hwc2_error_t err = HWC2_ERROR_NONE;
1135
1136 for (size_t i = 0; i < newLayerCnt; i++) {
1137
1138 EXPECT_NO_FATAL_FAILURE(createLayer(display, &layer, &err));
1139 if (err == HWC2_ERROR_NO_RESOURCES)
1140 break;
1141 if (err != HWC2_ERROR_NONE) {
1142 newLayers.clear();
1143 ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer";
1144 }
1145 newLayers.push_back(layer);
1146 }
1147
1148 *outLayers = std::move(newLayers);
1149 }
1150
destroyLayers(hwc2_display_t display,std::vector<hwc2_layer_t> && layers)1151 void destroyLayers(hwc2_display_t display,
1152 std::vector<hwc2_layer_t>&& layers)
1153 {
1154 for (hwc2_layer_t layer : layers) {
1155 EXPECT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1156 }
1157 }
1158
getInvalidConfig(hwc2_display_t display,hwc2_config_t * outConfig)1159 void getInvalidConfig(hwc2_display_t display, hwc2_config_t* outConfig)
1160 {
1161 std::vector<hwc2_config_t> configs;
1162
1163 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1164
1165 hwc2_config_t CONFIG_MAX = UINT32_MAX;
1166
1167 ASSERT_LE(configs.size() - 1, CONFIG_MAX) << "every config value"
1168 " (2^32 values) has been taken which shouldn't happen";
1169
1170 hwc2_config_t config;
1171 for (config = 0; config < CONFIG_MAX; config++) {
1172 if (std::count(configs.begin(), configs.end(), config) == 0)
1173 break;
1174 }
1175
1176 *outConfig = config;
1177 }
1178
1179 /* Calls a set property function from Hwc2Test to set a property value from
1180 * Hwc2TestLayer to hwc2_layer_t on hwc2_display_t */
1181 using TestLayerPropertyFunction = void (*)(Hwc2Test* test,
1182 hwc2_display_t display, hwc2_layer_t layer,
1183 Hwc2TestLayer* testLayer, hwc2_error_t* outErr);
1184
1185 /* Calls a set property function from Hwc2Test to set property values from
1186 * Hwc2TestLayers to hwc2_layer_t on hwc2_display_t */
1187 using TestLayerPropertiesFunction = void (*)(Hwc2Test* test,
1188 hwc2_display_t display, hwc2_layer_t layer,
1189 Hwc2TestLayers* testLayers);
1190
1191 /* Calls a set property function from Hwc2Test to set a bad property value
1192 * on hwc2_layer_t on hwc2_display_t */
1193 using TestLayerPropertyBadLayerFunction = void (*)(Hwc2Test* test,
1194 hwc2_display_t display, hwc2_layer_t layer,
1195 Hwc2TestLayer* testLayer, hwc2_error_t* outErr);
1196
1197 /* Calls a set property function from Hwc2Test to set a bad property value
1198 * on hwc2_layer_t on hwc2_display_t */
1199 using TestLayerPropertyBadParameterFunction = void (*)(Hwc2Test* test,
1200 hwc2_display_t display, hwc2_layer_t layer, hwc2_error_t* outErr);
1201
1202 /* Is called after a display is powered on and all layer properties have
1203 * been set. It should be used to test functions such as validate, accepting
1204 * changes, present, etc. */
1205 using TestDisplayLayersFunction = void (*)(Hwc2Test* test,
1206 hwc2_display_t display, const std::vector<hwc2_layer_t>& layers,
1207 Hwc2TestLayers* testLayers);
1208
1209 /* It is called on an non validated display */
1210 using TestDisplayNonValidatedLayersFunction = void (*)(Hwc2Test* test,
1211 hwc2_display_t display, std::vector<hwc2_layer_t>* layers);
1212
1213 /* Tests client target support on a particular display and config */
1214 using TestClientTargetSupportFunction = void (*)(Hwc2Test* test,
1215 hwc2_display_t display,
1216 const Hwc2TestClientTargetSupport& testClientTargetSupport);
1217
1218 /* Tests a particular active display config */
1219 using TestActiveDisplayConfigFunction = void (*)(Hwc2Test* test,
1220 hwc2_display_t display);
1221
1222 /* Tests a newly created virtual display */
1223 using TestCreateVirtualDisplayFunction = void (*)(Hwc2Test* test,
1224 hwc2_display_t display, Hwc2TestVirtualDisplay* testVirtualDisplay);
1225
1226 /* Advances a property of Hwc2TestLayer */
1227 using AdvanceProperty = bool (*)(Hwc2TestLayer* testLayer);
1228
1229 /* Advances properties of Hwc2TestLayers */
1230 using AdvanceProperties = bool (*)(Hwc2TestLayers* testLayer);
1231
1232 /* Advances properties of Hwc2TestClientTargetSupport */
1233 using AdvanceClientTargetSupport = bool (*)(
1234 Hwc2TestClientTargetSupport* testClientTargetSupport);
1235
1236 /* For each active display it cycles through each display config and tests
1237 * each property value. It creates a layer, sets the property and then
1238 * destroys the layer */
setLayerProperty(Hwc2TestCoverage coverage,TestLayerPropertyFunction function,AdvanceProperty advance)1239 void setLayerProperty(Hwc2TestCoverage coverage,
1240 TestLayerPropertyFunction function, AdvanceProperty advance)
1241 {
1242 for (auto display : mDisplays) {
1243 std::vector<hwc2_config_t> configs;
1244
1245 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1246
1247 for (auto config : configs) {
1248 hwc2_layer_t layer;
1249 Area displayArea;
1250
1251 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1252 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1253 &displayArea));
1254 Hwc2TestLayer testLayer(coverage, displayArea);
1255
1256 do {
1257 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1258
1259 ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1260 &testLayer, nullptr));
1261
1262 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1263 } while (advance(&testLayer));
1264 }
1265 }
1266 }
1267
1268 /* For each active display it cycles through each display config and tests
1269 * each property value. It creates a layer, cycles through each property
1270 * value and updates the layer property value and then destroys the layer */
setLayerPropertyUpdate(Hwc2TestCoverage coverage,TestLayerPropertyFunction function,AdvanceProperty advance)1271 void setLayerPropertyUpdate(Hwc2TestCoverage coverage,
1272 TestLayerPropertyFunction function, AdvanceProperty advance)
1273 {
1274 for (auto display : mDisplays) {
1275 std::vector<hwc2_config_t> configs;
1276
1277 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1278
1279 for (auto config : configs) {
1280 hwc2_layer_t layer;
1281 Area displayArea;
1282
1283 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1284 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1285 &displayArea));
1286 Hwc2TestLayer testLayer(coverage, displayArea);
1287
1288 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1289
1290 do {
1291 ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1292 &testLayer, nullptr));
1293 } while (advance(&testLayer));
1294
1295 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1296 }
1297 }
1298 }
1299
1300 /* For each active display it cycles through each display config and tests
1301 * each property value. It creates multiple layers, calls the
1302 * TestLayerPropertiesFunction to set property values and then
1303 * destroys the layers */
setLayerProperties(Hwc2TestCoverage coverage,size_t layerCnt,TestLayerPropertiesFunction function,AdvanceProperties advance)1304 void setLayerProperties(Hwc2TestCoverage coverage, size_t layerCnt,
1305 TestLayerPropertiesFunction function, AdvanceProperties advance)
1306 {
1307 for (auto display : mDisplays) {
1308 std::vector<hwc2_config_t> configs;
1309
1310 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1311
1312 for (auto config : configs) {
1313 std::vector<hwc2_layer_t> layers;
1314 Area displayArea;
1315
1316 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1317 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1318 &displayArea));
1319
1320 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1321 Hwc2TestLayers testLayers(layers, coverage, displayArea);
1322
1323 do {
1324 for (auto layer : layers) {
1325 EXPECT_NO_FATAL_FAILURE(function(this, display, layer,
1326 &testLayers));
1327 }
1328 } while (advance(&testLayers));
1329
1330 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
1331 }
1332 }
1333 }
1334
1335 /* For each active display it cycles through each display config.
1336 * 1) It attempts to set a valid property value to bad layer handle.
1337 * 2) It creates a layer x and attempts to set a valid property value to
1338 * layer x + 1
1339 * 3) It destroys the layer x and attempts to set a valid property value to
1340 * the destroyed layer x.
1341 */
setLayerPropertyBadLayer(Hwc2TestCoverage coverage,TestLayerPropertyBadLayerFunction function)1342 void setLayerPropertyBadLayer(Hwc2TestCoverage coverage,
1343 TestLayerPropertyBadLayerFunction function)
1344 {
1345 for (auto display : mDisplays) {
1346 std::vector<hwc2_config_t> configs;
1347
1348 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1349
1350 for (auto config : configs) {
1351 hwc2_layer_t layer = 0;
1352 Area displayArea;
1353 hwc2_error_t err = HWC2_ERROR_NONE;
1354
1355 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1356 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1357 &displayArea));
1358 Hwc2TestLayer testLayer(coverage, displayArea);
1359
1360 ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1361 &testLayer, &err));
1362 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1363
1364 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1365
1366 ASSERT_NO_FATAL_FAILURE(function(this, display, layer + 1,
1367 &testLayer, &err));
1368 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1369
1370 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1371
1372 ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1373 &testLayer, &err));
1374 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1375 }
1376 }
1377 }
1378
1379 /* For each active display it cycles through each display config and tests
1380 * each property value. It creates a layer, sets a bad property value and
1381 * then destroys the layer */
setLayerPropertyBadParameter(TestLayerPropertyBadParameterFunction function)1382 void setLayerPropertyBadParameter(TestLayerPropertyBadParameterFunction function)
1383 {
1384 for (auto display : mDisplays) {
1385 std::vector<hwc2_config_t> configs;
1386
1387 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1388
1389 for (auto config : configs) {
1390 hwc2_layer_t layer;
1391 hwc2_error_t err = HWC2_ERROR_NONE;
1392
1393 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1394
1395 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1396
1397 ASSERT_NO_FATAL_FAILURE(function(this, display, layer, &err));
1398 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong"
1399 " error code";
1400
1401 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1402 }
1403 }
1404 }
1405
1406 /* For each active display it powers on the display, cycles through each
1407 * config and creates a set of layers with a certain amount of coverage.
1408 * For each active display, for each config and for each set of layers,
1409 * it calls the TestDisplayLayersFunction */
displayLayers(Hwc2TestCoverage coverage,size_t layerCnt,TestDisplayLayersFunction function)1410 void displayLayers(Hwc2TestCoverage coverage, size_t layerCnt,
1411 TestDisplayLayersFunction function)
1412 {
1413 for (auto display : mDisplays) {
1414 std::vector<hwc2_config_t> configs;
1415
1416 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1417
1418 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1419
1420 for (auto config : configs) {
1421 Area displayArea;
1422 std::vector<hwc2_layer_t> layers;
1423
1424 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1425 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea));
1426
1427 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1428 Hwc2TestLayers testLayers(layers, coverage, displayArea);
1429
1430 do {
1431 bool skip;
1432
1433 ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers,
1434 &testLayers, &skip));
1435 if (!skip)
1436 EXPECT_NO_FATAL_FAILURE(function(this, display, layers,
1437 &testLayers));
1438
1439 } while (testLayers.advance());
1440
1441 ASSERT_NO_FATAL_FAILURE(destroyLayers(display,
1442 std::move(layers)));
1443 }
1444
1445 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1446 }
1447 }
1448
1449 /* For each active display, it calls the
1450 * TestDisplayNonValidatedLayersFunction on a variety on non-validated
1451 * layer combinations */
displayNonValidatedLayers(size_t layerCnt,TestDisplayNonValidatedLayersFunction function)1452 void displayNonValidatedLayers(size_t layerCnt,
1453 TestDisplayNonValidatedLayersFunction function)
1454 {
1455 for (auto display : mDisplays) {
1456 uint32_t numTypes, numRequests;
1457 std::vector<hwc2_layer_t> layers;
1458 bool hasChanges;
1459
1460 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1461
1462 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1463
1464 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1465
1466 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1467
1468 for (auto layer : layers) {
1469 ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer,
1470 HWC2_COMPOSITION_CLIENT));
1471 }
1472
1473 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1474
1475 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes,
1476 &numRequests, &hasChanges));
1477
1478 for (auto layer : layers) {
1479 ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer,
1480 HWC2_COMPOSITION_DEVICE));
1481 }
1482
1483 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1484
1485 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
1486
1487 EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1488
1489 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1490 }
1491 }
1492
1493 /* Test client target support on each config on each active display */
setClientTargetSupport(Hwc2TestCoverage coverage,TestClientTargetSupportFunction function,AdvanceClientTargetSupport advance)1494 void setClientTargetSupport(Hwc2TestCoverage coverage,
1495 TestClientTargetSupportFunction function,
1496 AdvanceClientTargetSupport advance)
1497 {
1498 for (auto display : mDisplays) {
1499 std::vector<hwc2_config_t> configs;
1500
1501 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1502
1503 for (auto config : configs) {
1504 Area displayArea;
1505
1506 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1507 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1508 &displayArea));
1509 Hwc2TestClientTargetSupport testClientTargetSupport(coverage,
1510 displayArea);
1511
1512 do {
1513 EXPECT_NO_FATAL_FAILURE(function(this, display,
1514 testClientTargetSupport));
1515
1516 } while (advance(&testClientTargetSupport));
1517 }
1518 }
1519 }
1520
1521 /* Cycles through each config on each active display and calls
1522 * a TestActiveDisplayConfigFunction */
setActiveDisplayConfig(TestActiveDisplayConfigFunction function)1523 void setActiveDisplayConfig(TestActiveDisplayConfigFunction function)
1524 {
1525 for (auto display : mDisplays) {
1526 std::vector<hwc2_config_t> configs;
1527
1528 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1529
1530 for (auto config : configs) {
1531 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1532
1533 EXPECT_NO_FATAL_FAILURE(function(this, display));
1534 }
1535 }
1536 }
1537
1538 /* Creates a virtual display for testing */
createVirtualDisplay(Hwc2TestCoverage coverage,TestCreateVirtualDisplayFunction function)1539 void createVirtualDisplay(Hwc2TestCoverage coverage,
1540 TestCreateVirtualDisplayFunction function)
1541 {
1542 Hwc2TestVirtualDisplay testVirtualDisplay(coverage);
1543
1544 do {
1545 hwc2_display_t display;
1546 hwc2_error_t err = HWC2_ERROR_NONE;
1547
1548 const UnsignedArea& dimension =
1549 testVirtualDisplay.getDisplayDimension();
1550 android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888;
1551
1552 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width,
1553 dimension.height, &desiredFormat, &display, &err));
1554
1555 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES
1556 || err == HWC2_ERROR_UNSUPPORTED)
1557 << "returned wrong error code";
1558 EXPECT_GE(desiredFormat, 0) << "invalid format";
1559
1560 if (err != HWC2_ERROR_NONE)
1561 continue;
1562
1563 EXPECT_NO_FATAL_FAILURE(function(this, display,
1564 &testVirtualDisplay));
1565
1566 ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display));
1567
1568 } while (testVirtualDisplay.advance());
1569 }
1570
1571
getActiveConfigAttribute(hwc2_display_t display,hwc2_attribute_t attribute,int32_t * outValue)1572 void getActiveConfigAttribute(hwc2_display_t display,
1573 hwc2_attribute_t attribute, int32_t* outValue)
1574 {
1575 hwc2_config_t config;
1576 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &config));
1577 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
1578 attribute, outValue));
1579 ASSERT_GE(*outValue, 0) << "failed to get valid "
1580 << getAttributeName(attribute);
1581 }
1582
getActiveDisplayArea(hwc2_display_t display,Area * displayArea)1583 void getActiveDisplayArea(hwc2_display_t display, Area* displayArea)
1584 {
1585 ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display,
1586 HWC2_ATTRIBUTE_WIDTH, &displayArea->width));
1587 ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display,
1588 HWC2_ATTRIBUTE_HEIGHT, &displayArea->height));
1589 }
1590
closeFences(hwc2_display_t display,int32_t presentFence)1591 void closeFences(hwc2_display_t display, int32_t presentFence)
1592 {
1593 std::vector<hwc2_layer_t> layers;
1594 std::vector<int32_t> fences;
1595 const int msWait = 3000;
1596
1597 if (presentFence >= 0) {
1598 ASSERT_GE(sync_wait(presentFence, msWait), 0);
1599 close(presentFence);
1600 }
1601
1602 ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences));
1603 EXPECT_EQ(layers.size(), fences.size());
1604
1605 for (int32_t fence : fences) {
1606 EXPECT_GE(sync_wait(fence, msWait), 0);
1607 if (fence >= 0)
1608 close(fence);
1609 }
1610 }
1611
setLayerProperties(hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayers * testLayers,bool * outSkip)1612 void setLayerProperties(hwc2_display_t display, hwc2_layer_t layer,
1613 Hwc2TestLayers* testLayers, bool* outSkip)
1614 {
1615 hwc2_composition_t composition;
1616 buffer_handle_t handle = nullptr;
1617 int32_t acquireFence;
1618 hwc2_error_t err = HWC2_ERROR_NONE;
1619 *outSkip = true;
1620
1621 if (!testLayers->contains(layer))
1622 return;
1623
1624 composition = testLayers->getComposition(layer);
1625
1626 /* If the device cannot support a buffer format, then do not continue */
1627 if ((composition == HWC2_COMPOSITION_DEVICE
1628 || composition == HWC2_COMPOSITION_CURSOR)
1629 && testLayers->getBuffer(layer, &handle, &acquireFence) < 0)
1630 return;
1631
1632 EXPECT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer,
1633 composition, &err));
1634 if (err == HWC2_ERROR_UNSUPPORTED)
1635 EXPECT_TRUE(composition != HWC2_COMPOSITION_CLIENT
1636 && composition != HWC2_COMPOSITION_DEVICE);
1637
1638 const hwc_rect_t cursor = testLayers->getCursorPosition(layer);
1639
1640 EXPECT_NO_FATAL_FAILURE(setLayerBuffer(display, layer, handle,
1641 acquireFence));
1642 EXPECT_NO_FATAL_FAILURE(setLayerBlendMode(display, layer,
1643 testLayers->getBlendMode(layer)));
1644 EXPECT_NO_FATAL_FAILURE(setLayerColor(display, layer,
1645 testLayers->getColor(layer)));
1646 EXPECT_NO_FATAL_FAILURE(setCursorPosition(display, layer, cursor.left,
1647 cursor.top));
1648 EXPECT_NO_FATAL_FAILURE(setLayerDataspace(display, layer,
1649 testLayers->getDataspace(layer)));
1650 EXPECT_NO_FATAL_FAILURE(setLayerDisplayFrame(display, layer,
1651 testLayers->getDisplayFrame(layer)));
1652 EXPECT_NO_FATAL_FAILURE(setLayerPlaneAlpha(display, layer,
1653 testLayers->getPlaneAlpha(layer)));
1654 EXPECT_NO_FATAL_FAILURE(setLayerSourceCrop(display, layer,
1655 testLayers->getSourceCrop(layer)));
1656 EXPECT_NO_FATAL_FAILURE(setLayerSurfaceDamage(display, layer,
1657 testLayers->getSurfaceDamage(layer)));
1658 EXPECT_NO_FATAL_FAILURE(setLayerTransform(display, layer,
1659 testLayers->getTransform(layer)));
1660 EXPECT_NO_FATAL_FAILURE(setLayerVisibleRegion(display, layer,
1661 testLayers->getVisibleRegion(layer)));
1662 EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer,
1663 testLayers->getZOrder(layer)));
1664
1665 *outSkip = false;
1666 }
1667
setLayerProperties(hwc2_display_t display,const std::vector<hwc2_layer_t> & layers,Hwc2TestLayers * testLayers,bool * outSkip)1668 void setLayerProperties(hwc2_display_t display,
1669 const std::vector<hwc2_layer_t>& layers,
1670 Hwc2TestLayers* testLayers, bool* outSkip)
1671 {
1672 for (auto layer : layers) {
1673 EXPECT_NO_FATAL_FAILURE(setLayerProperties(display, layer,
1674 testLayers, outSkip));
1675 if (*outSkip)
1676 return;
1677 }
1678 }
1679
setClientTarget(hwc2_display_t display,Hwc2TestClientTarget * testClientTarget,const Hwc2TestLayers & testLayers,const std::set<hwc2_layer_t> & clientLayers,const std::set<hwc2_layer_t> & clearLayers,bool flipClientTarget,const Area & displayArea)1680 void setClientTarget(hwc2_display_t display,
1681 Hwc2TestClientTarget* testClientTarget,
1682 const Hwc2TestLayers& testLayers,
1683 const std::set<hwc2_layer_t>& clientLayers,
1684 const std::set<hwc2_layer_t>& clearLayers, bool flipClientTarget,
1685 const Area& displayArea)
1686 {
1687 android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN;
1688 hwc_region_t damage = { };
1689 buffer_handle_t handle;
1690 int32_t acquireFence;
1691
1692 ASSERT_EQ(testClientTarget->getBuffer(testLayers, clientLayers,
1693 clearLayers, flipClientTarget, displayArea, &handle,
1694 &acquireFence), 0);
1695 EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence,
1696 dataspace, damage));
1697 }
1698
presentDisplays(size_t layerCnt,Hwc2TestCoverage coverage,const std::unordered_map<Hwc2TestPropertyName,Hwc2TestCoverage> & coverageExceptions,bool optimize)1699 void presentDisplays(size_t layerCnt, Hwc2TestCoverage coverage,
1700 const std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage>&
1701 coverageExceptions, bool optimize)
1702 {
1703 for (auto display : mDisplays) {
1704 std::vector<hwc2_config_t> configs;
1705
1706 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1707 ASSERT_NO_FATAL_FAILURE(enableVsync(display));
1708
1709 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1710
1711 for (auto config : configs) {
1712 Area displayArea;
1713 std::vector<hwc2_layer_t> layers;
1714
1715 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1716 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1717 &displayArea));
1718
1719 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1720 Hwc2TestLayers testLayers(layers, coverage, displayArea,
1721 coverageExceptions);
1722
1723 if (optimize && !testLayers.optimizeLayouts())
1724 continue;
1725
1726 std::set<hwc2_layer_t> clientLayers;
1727 std::set<hwc2_layer_t> clearLayers;
1728 Hwc2TestClientTarget testClientTarget;
1729
1730 do {
1731 uint32_t numTypes, numRequests;
1732 bool hasChanges, skip;
1733 bool flipClientTarget;
1734 int32_t presentFence;
1735
1736 ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers,
1737 &testLayers, &skip));
1738 if (skip)
1739 continue;
1740
1741 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes,
1742 &numRequests, &hasChanges));
1743 if (hasChanges)
1744 EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size()))
1745 << "wrong number of requests";
1746
1747 ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display,
1748 testLayers, layers, numTypes, &clientLayers));
1749 ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers,
1750 numRequests, &clearLayers, &flipClientTarget));
1751 ASSERT_NO_FATAL_FAILURE(setClientTarget(display,
1752 &testClientTarget, testLayers, clientLayers,
1753 clearLayers, flipClientTarget, displayArea));
1754 ASSERT_NO_FATAL_FAILURE(acceptDisplayChanges(display));
1755
1756 ASSERT_NO_FATAL_FAILURE(waitForVsync());
1757
1758 EXPECT_NO_FATAL_FAILURE(presentDisplay(display,
1759 &presentFence));
1760
1761 ASSERT_NO_FATAL_FAILURE(closeFences(display, presentFence));
1762
1763 } while (testLayers.advance());
1764
1765 ASSERT_NO_FATAL_FAILURE(destroyLayers(display,
1766 std::move(layers)));
1767 }
1768
1769 ASSERT_NO_FATAL_FAILURE(disableVsync(display));
1770 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1771 }
1772 }
1773
1774 hwc2_device_t* mHwc2Device = nullptr;
1775
1776 enum class Hwc2TestHotplugStatus {
1777 Init = 1,
1778 Receiving,
1779 Done,
1780 };
1781
1782 std::mutex mHotplugMutex;
1783 std::condition_variable mHotplugCv;
1784 Hwc2TestHotplugStatus mHotplugStatus = Hwc2TestHotplugStatus::Init;
1785 std::unordered_set<hwc2_display_t> mDisplays;
1786
1787 /* Store all created layers that have not been destroyed. If an ASSERT_*
1788 * fails, then destroy the layers on exit */
1789 std::set<std::pair<hwc2_display_t, hwc2_layer_t>> mLayers;
1790
1791 /* Store the power mode state. If it is not HWC2_POWER_MODE_OFF when
1792 * tearing down the test cases, change it to HWC2_POWER_MODE_OFF */
1793 std::set<hwc2_display_t> mActiveDisplays;
1794
1795 /* Store all created virtual displays that have not been destroyed. If an
1796 * ASSERT_* fails, then destroy the virtual displays on exit */
1797 std::set<hwc2_display_t> mVirtualDisplays;
1798
1799 std::mutex mVsyncMutex;
1800 std::condition_variable mVsyncCv;
1801 hwc2_display_t mVsyncDisplay;
1802 int64_t mVsyncTimestamp = -1;
1803 };
1804
hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,hwc2_display_t display,int32_t connection)1805 void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,
1806 hwc2_display_t display, int32_t connection)
1807 {
1808 if (callbackData)
1809 static_cast<Hwc2Test*>(callbackData)->hotplugCallback(display,
1810 connection);
1811 }
1812
hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,hwc2_display_t display,int64_t timestamp)1813 void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,
1814 hwc2_display_t display, int64_t timestamp)
1815 {
1816 if (callbackData)
1817 static_cast<Hwc2Test*>(callbackData)->vsyncCallback(display,
1818 timestamp);
1819 }
1820
setBlendMode(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1821 void setBlendMode(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1822 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1823 {
1824 EXPECT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,
1825 testLayer->getBlendMode(), outErr));
1826 }
1827
setBuffer(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1828 void setBuffer(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1829 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1830 {
1831 buffer_handle_t handle;
1832 android::base::unique_fd acquireFence;
1833 hwc2_composition_t composition = testLayer->getComposition();
1834
1835 if (composition == HWC2_COMPOSITION_CLIENT
1836 || composition == HWC2_COMPOSITION_SOLID_COLOR
1837 || composition == HWC2_COMPOSITION_SIDEBAND)
1838 return;
1839
1840 if (testLayer->getBuffer(&handle, &acquireFence) < 0)
1841 return;
1842
1843 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer,
1844 composition));
1845 EXPECT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer,
1846 handle, acquireFence, outErr));
1847 }
1848
setColor(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1849 void setColor(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1850 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1851 {
1852 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,
1853 layer, HWC2_COMPOSITION_SOLID_COLOR));
1854 ASSERT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,
1855 layer, testLayer->getPlaneAlpha()));
1856 ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display,
1857 layer, testLayer->getBlendMode()));
1858 EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,
1859 testLayer->getColor(), outErr));
1860 }
1861
setComposition(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1862 void setComposition(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1863 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1864 {
1865 hwc2_composition_t composition = testLayer->getComposition();
1866 hwc2_error_t err = HWC2_ERROR_NONE;
1867
1868 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer,
1869 composition, &err));
1870 if (outErr) {
1871 *outErr = err;
1872 return;
1873 }
1874
1875 if (composition != HWC2_COMPOSITION_SIDEBAND) {
1876 EXPECT_EQ(err, HWC2_ERROR_NONE) << "returned wrong error code";
1877 } else {
1878 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED)
1879 << "returned wrong error code";
1880 }
1881 }
1882
setCursorPosition(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1883 void setCursorPosition(Hwc2Test* test, hwc2_display_t display,
1884 hwc2_layer_t layer, Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1885 {
1886 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,
1887 layer, HWC2_COMPOSITION_CURSOR));
1888
1889 const hwc_rect_t cursorPosition = testLayer->getCursorPosition();
1890 EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer,
1891 cursorPosition.left, cursorPosition.top, outErr));
1892 }
1893
setDataspace(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1894 void setDataspace(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1895 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1896 {
1897 EXPECT_NO_FATAL_FAILURE(test->setLayerDataspace(display, layer,
1898 testLayer->getDataspace(), outErr));
1899 }
1900
setDisplayFrame(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1901 void setDisplayFrame(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1902 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1903 {
1904 EXPECT_NO_FATAL_FAILURE(test->setLayerDisplayFrame(display, layer,
1905 testLayer->getDisplayFrame(), outErr));
1906 }
1907
setPlaneAlpha(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1908 void setPlaneAlpha(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1909 Hwc2TestLayer* testLayer, hwc2_error_t *outErr)
1910 {
1911 ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,
1912 testLayer->getBlendMode()));
1913 EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, layer,
1914 testLayer->getPlaneAlpha(), outErr));
1915 }
1916
setSourceCrop(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1917 void setSourceCrop(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1918 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1919 {
1920 EXPECT_NO_FATAL_FAILURE(test->setLayerSourceCrop(display, layer,
1921 testLayer->getSourceCrop(), outErr));
1922 }
1923
setSurfaceDamage(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1924 void setSurfaceDamage(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1925 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1926 {
1927 EXPECT_NO_FATAL_FAILURE(test->setLayerSurfaceDamage(display, layer,
1928 testLayer->getSurfaceDamage(), outErr));
1929 }
1930
setTransform(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1931 void setTransform(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1932 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1933 {
1934 EXPECT_NO_FATAL_FAILURE(test->setLayerTransform(display, layer,
1935 testLayer->getTransform(), outErr));
1936 }
1937
setVisibleRegion(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1938 void setVisibleRegion(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1939 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1940 {
1941 EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display, layer,
1942 testLayer->getVisibleRegion(), outErr));
1943 }
1944
setZOrder(Hwc2Test * test,hwc2_display_t display,hwc2_layer_t layer,Hwc2TestLayer * testLayer,hwc2_error_t * outErr)1945 void setZOrder(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1946 Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1947 {
1948 EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,
1949 testLayer->getZOrder(), outErr));
1950 }
1951
advanceBlendMode(Hwc2TestLayer * testLayer)1952 bool advanceBlendMode(Hwc2TestLayer* testLayer)
1953 {
1954 return testLayer->advanceBlendMode();
1955 }
1956
advanceBuffer(Hwc2TestLayer * testLayer)1957 bool advanceBuffer(Hwc2TestLayer* testLayer)
1958 {
1959 if (testLayer->advanceComposition())
1960 return true;
1961 return testLayer->advanceBufferArea();
1962 }
1963
advanceColor(Hwc2TestLayer * testLayer)1964 bool advanceColor(Hwc2TestLayer* testLayer)
1965 {
1966 /* Color depends on blend mode so advance blend mode last so color is not
1967 * force to update as often */
1968 if (testLayer->advancePlaneAlpha())
1969 return true;
1970 if (testLayer->advanceColor())
1971 return true;
1972 return testLayer->advanceBlendMode();
1973 }
1974
advanceComposition(Hwc2TestLayer * testLayer)1975 bool advanceComposition(Hwc2TestLayer* testLayer)
1976 {
1977 return testLayer->advanceComposition();
1978 }
1979
advanceCursorPosition(Hwc2TestLayer * testLayer)1980 bool advanceCursorPosition(Hwc2TestLayer* testLayer)
1981 {
1982 return testLayer->advanceCursorPosition();
1983 }
1984
advanceDataspace(Hwc2TestLayer * testLayer)1985 bool advanceDataspace(Hwc2TestLayer* testLayer)
1986 {
1987 return testLayer->advanceDataspace();
1988 }
1989
advanceDisplayFrame(Hwc2TestLayer * testLayer)1990 bool advanceDisplayFrame(Hwc2TestLayer* testLayer)
1991 {
1992 return testLayer->advanceDisplayFrame();
1993 }
1994
advancePlaneAlpha(Hwc2TestLayer * testLayer)1995 bool advancePlaneAlpha(Hwc2TestLayer* testLayer)
1996 {
1997 return testLayer->advancePlaneAlpha();
1998 }
1999
advanceSourceCrop(Hwc2TestLayer * testLayer)2000 bool advanceSourceCrop(Hwc2TestLayer* testLayer)
2001 {
2002 if (testLayer->advanceSourceCrop())
2003 return true;
2004 return testLayer->advanceBufferArea();
2005 }
2006
advanceSurfaceDamage(Hwc2TestLayer * testLayer)2007 bool advanceSurfaceDamage(Hwc2TestLayer* testLayer)
2008 {
2009 if (testLayer->advanceSurfaceDamage())
2010 return true;
2011 return testLayer->advanceBufferArea();
2012 }
2013
advanceTransform(Hwc2TestLayer * testLayer)2014 bool advanceTransform(Hwc2TestLayer* testLayer)
2015 {
2016 return testLayer->advanceTransform();
2017 }
2018
advanceVisibleRegions(Hwc2TestLayers * testLayers)2019 bool advanceVisibleRegions(Hwc2TestLayers* testLayers)
2020 {
2021 return testLayers->advanceVisibleRegions();
2022 }
2023
advanceClientTargetSupport(Hwc2TestClientTargetSupport * testClientTargetSupport)2024 bool advanceClientTargetSupport(
2025 Hwc2TestClientTargetSupport* testClientTargetSupport)
2026 {
2027 return testClientTargetSupport->advance();
2028 }
2029
2030 static const std::array<hwc2_function_descriptor_t, 42> requiredFunctions = {{
2031 HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES,
2032 HWC2_FUNCTION_CREATE_LAYER,
2033 HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY,
2034 HWC2_FUNCTION_DESTROY_LAYER,
2035 HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY,
2036 HWC2_FUNCTION_DUMP,
2037 HWC2_FUNCTION_GET_ACTIVE_CONFIG,
2038 HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES,
2039 HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT,
2040 HWC2_FUNCTION_GET_COLOR_MODES,
2041 HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE,
2042 HWC2_FUNCTION_GET_DISPLAY_CONFIGS,
2043 HWC2_FUNCTION_GET_DISPLAY_NAME,
2044 HWC2_FUNCTION_GET_DISPLAY_REQUESTS,
2045 HWC2_FUNCTION_GET_DISPLAY_TYPE,
2046 HWC2_FUNCTION_GET_DOZE_SUPPORT,
2047 HWC2_FUNCTION_GET_HDR_CAPABILITIES,
2048 HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT,
2049 HWC2_FUNCTION_GET_RELEASE_FENCES,
2050 HWC2_FUNCTION_PRESENT_DISPLAY,
2051 HWC2_FUNCTION_REGISTER_CALLBACK,
2052 HWC2_FUNCTION_SET_ACTIVE_CONFIG,
2053 HWC2_FUNCTION_SET_CLIENT_TARGET,
2054 HWC2_FUNCTION_SET_COLOR_MODE,
2055 HWC2_FUNCTION_SET_COLOR_TRANSFORM,
2056 HWC2_FUNCTION_SET_CURSOR_POSITION,
2057 HWC2_FUNCTION_SET_LAYER_BLEND_MODE,
2058 HWC2_FUNCTION_SET_LAYER_BUFFER,
2059 HWC2_FUNCTION_SET_LAYER_COLOR,
2060 HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE,
2061 HWC2_FUNCTION_SET_LAYER_DATASPACE,
2062 HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME,
2063 HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA,
2064 HWC2_FUNCTION_SET_LAYER_SOURCE_CROP,
2065 HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE,
2066 HWC2_FUNCTION_SET_LAYER_TRANSFORM,
2067 HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION,
2068 HWC2_FUNCTION_SET_LAYER_Z_ORDER,
2069 HWC2_FUNCTION_SET_OUTPUT_BUFFER,
2070 HWC2_FUNCTION_SET_POWER_MODE,
2071 HWC2_FUNCTION_SET_VSYNC_ENABLED,
2072 HWC2_FUNCTION_VALIDATE_DISPLAY,
2073 }};
2074
2075 /* TESTCASE: Tests that the HWC2 supports all required functions. */
TEST_F(Hwc2Test,GET_FUNCTION)2076 TEST_F(Hwc2Test, GET_FUNCTION)
2077 {
2078 for (hwc2_function_descriptor_t descriptor : requiredFunctions) {
2079 hwc2_function_pointer_t pfn = getFunction(descriptor);
2080 EXPECT_TRUE(pfn) << "failed to get function "
2081 << getFunctionDescriptorName(descriptor);
2082 }
2083 }
2084
2085 /* TESTCASE: Tests that the HWC2 fails to retrieve and invalid function. */
TEST_F(Hwc2Test,GET_FUNCTION_invalid_function)2086 TEST_F(Hwc2Test, GET_FUNCTION_invalid_function)
2087 {
2088 hwc2_function_pointer_t pfn = getFunction(HWC2_FUNCTION_INVALID);
2089 EXPECT_FALSE(pfn) << "failed to get invalid function";
2090 }
2091
2092 /* TESTCASE: Tests that the HWC2 does not return an invalid capability. */
TEST_F(Hwc2Test,GET_CAPABILITIES)2093 TEST_F(Hwc2Test, GET_CAPABILITIES)
2094 {
2095 std::vector<hwc2_capability_t> capabilities;
2096
2097 getCapabilities(&capabilities);
2098
2099 EXPECT_EQ(std::count(capabilities.begin(), capabilities.end(),
2100 HWC2_CAPABILITY_INVALID), 0);
2101 }
2102
2103 static const std::array<hwc2_callback_descriptor_t, 3> callbackDescriptors = {{
2104 HWC2_CALLBACK_HOTPLUG,
2105 HWC2_CALLBACK_REFRESH,
2106 HWC2_CALLBACK_VSYNC,
2107 }};
2108
2109 /* TESTCASE: Tests that the HWC2 can successfully register all required
2110 * callback functions. */
TEST_F(Hwc2Test,REGISTER_CALLBACK)2111 TEST_F(Hwc2Test, REGISTER_CALLBACK)
2112 {
2113 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2114 const_cast<char*>("data"));
2115
2116 for (auto descriptor : callbackDescriptors) {
2117 ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data,
2118 []() { return; }));
2119 }
2120 }
2121
2122 /* TESTCASE: Test that the HWC2 fails to register invalid callbacks. */
TEST_F(Hwc2Test,REGISTER_CALLBACK_bad_parameter)2123 TEST_F(Hwc2Test, REGISTER_CALLBACK_bad_parameter)
2124 {
2125 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2126 const_cast<char*>("data"));
2127 hwc2_error_t err = HWC2_ERROR_NONE;
2128
2129 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_INVALID, data,
2130 []() { return; }, &err));
2131 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
2132 }
2133
2134 /* TESTCASE: Tests that the HWC2 can register a callback with null data. */
TEST_F(Hwc2Test,REGISTER_CALLBACK_null_data)2135 TEST_F(Hwc2Test, REGISTER_CALLBACK_null_data)
2136 {
2137 hwc2_callback_data_t data = nullptr;
2138
2139 for (auto descriptor : callbackDescriptors) {
2140 ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data,
2141 []() { return; }));
2142 }
2143 }
2144
2145 /* TESTCASE: Tests that the HWC2 returns the correct display type for each
2146 * physical display. */
TEST_F(Hwc2Test,GET_DISPLAY_TYPE)2147 TEST_F(Hwc2Test, GET_DISPLAY_TYPE)
2148 {
2149 for (auto display : mDisplays) {
2150 hwc2_display_type_t type;
2151
2152 ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type));
2153 EXPECT_EQ(type, HWC2_DISPLAY_TYPE_PHYSICAL) << "failed to return"
2154 " correct display type";
2155 }
2156 }
2157
2158 /* TESTCASE: Tests that the HWC2 returns an error when the display type of a bad
2159 * display is requested. */
TEST_F(Hwc2Test,GET_DISPLAY_TYPE_bad_display)2160 TEST_F(Hwc2Test, GET_DISPLAY_TYPE_bad_display)
2161 {
2162 hwc2_display_t display;
2163 hwc2_display_type_t type;
2164 hwc2_error_t err = HWC2_ERROR_NONE;
2165
2166 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2167
2168 ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type, &err));
2169 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2170 }
2171
2172 /* TESTCASE: Tests that the HWC2 can create and destroy layers. */
TEST_F(Hwc2Test,CREATE_DESTROY_LAYER)2173 TEST_F(Hwc2Test, CREATE_DESTROY_LAYER)
2174 {
2175 for (auto display : mDisplays) {
2176 hwc2_layer_t layer;
2177
2178 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
2179
2180 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
2181 }
2182 }
2183
2184 /* TESTCASE: Tests that the HWC2 cannot create a layer for a bad display */
TEST_F(Hwc2Test,CREATE_LAYER_bad_display)2185 TEST_F(Hwc2Test, CREATE_LAYER_bad_display)
2186 {
2187 hwc2_display_t display;
2188 hwc2_layer_t layer;
2189 hwc2_error_t err = HWC2_ERROR_NONE;
2190
2191 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2192
2193 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer, &err));
2194 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2195 }
2196
2197 /* TESTCASE: Tests that the HWC2 will either support a large number of resources
2198 * or will return no resources. */
TEST_F(Hwc2Test,CREATE_LAYER_no_resources)2199 TEST_F(Hwc2Test, CREATE_LAYER_no_resources)
2200 {
2201 const size_t layerCnt = 1000;
2202
2203 for (auto display : mDisplays) {
2204 std::vector<hwc2_layer_t> layers;
2205
2206 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
2207
2208 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
2209 }
2210 }
2211
2212 /* TESTCASE: Tests that the HWC2 cannot destroy a layer for a bad display */
TEST_F(Hwc2Test,DESTROY_LAYER_bad_display)2213 TEST_F(Hwc2Test, DESTROY_LAYER_bad_display)
2214 {
2215 hwc2_display_t badDisplay;
2216
2217 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&badDisplay));
2218
2219 for (auto display : mDisplays) {
2220 hwc2_layer_t layer = 0;
2221 hwc2_error_t err = HWC2_ERROR_NONE;
2222
2223 ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err));
2224 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2225
2226 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
2227
2228 ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err));
2229 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2230
2231 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
2232 }
2233 }
2234
2235 /* TESTCASE: Tests that the HWC2 cannot destory a bad layer */
TEST_F(Hwc2Test,DESTROY_LAYER_bad_layer)2236 TEST_F(Hwc2Test, DESTROY_LAYER_bad_layer)
2237 {
2238 for (auto display : mDisplays) {
2239 hwc2_layer_t layer;
2240 hwc2_error_t err = HWC2_ERROR_NONE;
2241
2242 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX / 2, &err));
2243 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2244
2245 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 0, &err));
2246 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2247
2248 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX - 1, &err));
2249 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2250
2251 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 1, &err));
2252 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2253
2254 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX, &err));
2255 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2256
2257 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
2258
2259 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer + 1, &err));
2260 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2261
2262 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
2263
2264 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer, &err));
2265 EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2266 }
2267 }
2268
2269 static const std::array<hwc2_attribute_t, 2> requiredAttributes = {{
2270 HWC2_ATTRIBUTE_WIDTH,
2271 HWC2_ATTRIBUTE_HEIGHT,
2272 }};
2273
2274 static const std::array<hwc2_attribute_t, 3> optionalAttributes = {{
2275 HWC2_ATTRIBUTE_VSYNC_PERIOD,
2276 HWC2_ATTRIBUTE_DPI_X,
2277 HWC2_ATTRIBUTE_DPI_Y,
2278 }};
2279
2280 /* TESTCASE: Tests that the HWC2 can return display attributes for a valid
2281 * config. */
TEST_F(Hwc2Test,GET_DISPLAY_ATTRIBUTE)2282 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE)
2283 {
2284 for (auto display : mDisplays) {
2285 std::vector<hwc2_config_t> configs;
2286
2287 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2288
2289 for (auto config : configs) {
2290 int32_t value;
2291
2292 for (auto attribute : requiredAttributes) {
2293 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2294 attribute, &value));
2295 EXPECT_GE(value, 0) << "missing required attribute "
2296 << getAttributeName(attribute) << " for config "
2297 << config;
2298 }
2299 for (auto attribute : optionalAttributes) {
2300 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2301 attribute, &value));
2302 }
2303 }
2304 }
2305 }
2306
2307 /* TESTCASE: Tests that the HWC2 will return a value of -1 for an invalid
2308 * attribute */
TEST_F(Hwc2Test,GET_DISPLAY_ATTRIBUTE_invalid_attribute)2309 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_invalid_attribute)
2310 {
2311 const hwc2_attribute_t attribute = HWC2_ATTRIBUTE_INVALID;
2312
2313 for (auto display : mDisplays) {
2314 std::vector<hwc2_config_t> configs;
2315
2316 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2317
2318 for (auto config : configs) {
2319 int32_t value;
2320 hwc2_error_t err = HWC2_ERROR_NONE;
2321
2322 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2323 attribute, &value, &err));
2324 EXPECT_EQ(value, -1) << "failed to return -1 for an invalid"
2325 " attribute for config " << config;
2326 }
2327 }
2328 }
2329
2330 /* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad display */
TEST_F(Hwc2Test,GET_DISPLAY_ATTRIBUTE_bad_display)2331 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_display)
2332 {
2333 hwc2_display_t display;
2334 const hwc2_config_t config = 0;
2335 int32_t value;
2336 hwc2_error_t err = HWC2_ERROR_NONE;
2337
2338 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2339
2340 for (auto attribute : requiredAttributes) {
2341 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute,
2342 &value, &err));
2343 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2344 }
2345
2346 for (auto attribute : optionalAttributes) {
2347 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute,
2348 &value, &err));
2349 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2350 }
2351 }
2352
2353 /* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad config */
TEST_F(Hwc2Test,GET_DISPLAY_ATTRIBUTE_bad_config)2354 TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_config)
2355 {
2356 for (auto display : mDisplays) {
2357 hwc2_config_t config;
2358 int32_t value;
2359 hwc2_error_t err = HWC2_ERROR_NONE;
2360
2361 ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config));
2362
2363 for (auto attribute : requiredAttributes) {
2364 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2365 attribute, &value, &err));
2366 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2367 }
2368
2369 for (auto attribute : optionalAttributes) {
2370 ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2371 attribute, &value, &err));
2372 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2373 }
2374 }
2375 }
2376
2377 /* TESTCASE: Tests that the HWC2 will get display configs for active displays */
TEST_F(Hwc2Test,GET_DISPLAY_CONFIGS)2378 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS)
2379 {
2380 for (auto display : mDisplays) {
2381 std::vector<hwc2_config_t> configs;
2382
2383 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2384 }
2385 }
2386
2387 /* TESTCASE: Tests that the HWC2 will not get display configs for bad displays */
TEST_F(Hwc2Test,GET_DISPLAY_CONFIGS_bad_display)2388 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_bad_display)
2389 {
2390 hwc2_display_t display;
2391 std::vector<hwc2_config_t> configs;
2392 hwc2_error_t err = HWC2_ERROR_NONE;
2393
2394 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2395
2396 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs, &err));
2397
2398 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2399 EXPECT_TRUE(configs.empty()) << "returned configs for bad display";
2400 }
2401
2402 /* TESTCASE: Tests that the HWC2 will return the same config list multiple
2403 * times in a row. */
TEST_F(Hwc2Test,GET_DISPLAY_CONFIGS_same)2404 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_same)
2405 {
2406 for (auto display : mDisplays) {
2407 std::vector<hwc2_config_t> configs1, configs2;
2408
2409 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs1));
2410 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs2));
2411
2412 EXPECT_TRUE(std::is_permutation(configs1.begin(), configs1.end(),
2413 configs2.begin())) << "returned two different config sets";
2414 }
2415 }
2416
2417 /* TESTCASE: Tests that the HWC2 does not return duplicate display configs */
TEST_F(Hwc2Test,GET_DISPLAY_CONFIGS_duplicate)2418 TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_duplicate)
2419 {
2420 for (auto display : mDisplays) {
2421 std::vector<hwc2_config_t> configs;
2422
2423 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2424
2425 std::unordered_set<hwc2_config_t> configsSet(configs.begin(),
2426 configs.end());
2427 EXPECT_EQ(configs.size(), configsSet.size()) << "returned duplicate"
2428 " configs";
2429 }
2430 }
2431
2432 /* TESTCASE: Tests that the HWC2 returns the active config for a display */
TEST_F(Hwc2Test,GET_ACTIVE_CONFIG)2433 TEST_F(Hwc2Test, GET_ACTIVE_CONFIG)
2434 {
2435 for (auto display : mDisplays) {
2436 std::vector<hwc2_config_t> configs;
2437
2438 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2439
2440 for (auto config : configs) {
2441 hwc2_config_t activeConfig;
2442
2443 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
2444 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig));
2445
2446 EXPECT_EQ(activeConfig, config) << "failed to get active config";
2447 }
2448 }
2449 }
2450
2451 /* TESTCASE: Tests that the HWC2 does not return an active config for a bad
2452 * display. */
TEST_F(Hwc2Test,GET_ACTIVE_CONFIG_bad_display)2453 TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_display)
2454 {
2455 hwc2_display_t display;
2456 hwc2_config_t activeConfig;
2457 hwc2_error_t err = HWC2_ERROR_NONE;
2458
2459 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2460
2461 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err));
2462
2463 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2464 }
2465
2466 /* TESTCASE: Tests that the HWC2 either begins with a valid active config
2467 * or returns an error when getActiveConfig is called. */
TEST_F(Hwc2Test,GET_ACTIVE_CONFIG_bad_config)2468 TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_config)
2469 {
2470 for (auto display : mDisplays) {
2471 std::vector<hwc2_config_t> configs;
2472 hwc2_config_t activeConfig;
2473 hwc2_error_t err = HWC2_ERROR_NONE;
2474
2475 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2476
2477 if (configs.empty())
2478 return;
2479
2480 ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err));
2481 if (err == HWC2_ERROR_NONE) {
2482 EXPECT_NE(std::count(configs.begin(), configs.end(),
2483 activeConfig), 0) << "active config is not found in "
2484 " configs for display";
2485 } else {
2486 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2487 }
2488 }
2489 }
2490
2491 /* TESTCASE: Tests that the HWC2 can set every display config as an active
2492 * config */
TEST_F(Hwc2Test,SET_ACTIVE_CONFIG)2493 TEST_F(Hwc2Test, SET_ACTIVE_CONFIG)
2494 {
2495 for (auto display : mDisplays) {
2496 std::vector<hwc2_config_t> configs;
2497
2498 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2499
2500 for (auto config : configs) {
2501 EXPECT_NO_FATAL_FAILURE(setActiveConfig(display, config));
2502 }
2503 }
2504 }
2505
2506 /* TESTCASE: Tests that the HWC2 cannot set an active config for a bad display */
TEST_F(Hwc2Test,SET_ACTIVE_CONFIG_bad_display)2507 TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_display)
2508 {
2509 hwc2_display_t display;
2510 const hwc2_config_t config = 0;
2511 hwc2_error_t err = HWC2_ERROR_NONE;
2512
2513 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2514
2515 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err));
2516 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2517 }
2518
2519 /* TESTCASE: Tests that the HWC2 cannot set an invalid active config */
TEST_F(Hwc2Test,SET_ACTIVE_CONFIG_bad_config)2520 TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_config)
2521 {
2522 for (auto display : mDisplays) {
2523 hwc2_config_t config;
2524 hwc2_error_t err = HWC2_ERROR_NONE;
2525
2526 ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config));
2527
2528 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err));
2529 EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2530 }
2531 }
2532
2533 /* TESTCASE: Tests that the HWC2 returns a valid value for getDozeSupport. */
TEST_F(Hwc2Test,GET_DOZE_SUPPORT)2534 TEST_F(Hwc2Test, GET_DOZE_SUPPORT)
2535 {
2536 for (auto display : mDisplays) {
2537 int32_t support = -1;
2538
2539 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
2540
2541 EXPECT_TRUE(support == 0 || support == 1) << "invalid doze support value";
2542 }
2543 }
2544
2545 /* TESTCASE: Tests that the HWC2 cannot get doze support for a bad display. */
TEST_F(Hwc2Test,GET_DOZE_SUPPORT_bad_display)2546 TEST_F(Hwc2Test, GET_DOZE_SUPPORT_bad_display)
2547 {
2548 hwc2_display_t display;
2549 int32_t support = -1;
2550 hwc2_error_t err = HWC2_ERROR_NONE;
2551
2552 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2553
2554 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
2555
2556 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2557 }
2558
2559 /* TESTCASE: Tests that the HWC2 can set all supported power modes */
TEST_F(Hwc2Test,SET_POWER_MODE)2560 TEST_F(Hwc2Test, SET_POWER_MODE)
2561 {
2562 for (auto display : mDisplays) {
2563 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2564 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2565
2566 int32_t support = -1;
2567 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
2568 if (support != 1)
2569 return;
2570
2571 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
2572 ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2573 HWC2_POWER_MODE_DOZE_SUSPEND));
2574
2575 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2576 }
2577 }
2578
2579 /* TESTCASE: Tests that the HWC2 cannot set a power mode for a bad display. */
TEST_F(Hwc2Test,SET_POWER_MODE_bad_display)2580 TEST_F(Hwc2Test, SET_POWER_MODE_bad_display)
2581 {
2582 hwc2_display_t display;
2583 hwc2_error_t err = HWC2_ERROR_NONE;
2584
2585 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2586
2587 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON, &err));
2588 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2589
2590 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF, &err));
2591 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2592
2593 int32_t support = -1;
2594 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
2595 if (support != 1)
2596 return;
2597
2598 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE, &err));
2599 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2600
2601 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE_SUSPEND,
2602 &err));
2603 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2604 }
2605
2606 /* TESTCASE: Tests that the HWC2 cannot set an invalid power mode value. */
TEST_F(Hwc2Test,SET_POWER_MODE_bad_parameter)2607 TEST_F(Hwc2Test, SET_POWER_MODE_bad_parameter)
2608 {
2609 for (auto display : mDisplays) {
2610 hwc2_power_mode_t mode = static_cast<hwc2_power_mode_t>(
2611 HWC2_POWER_MODE_DOZE_SUSPEND + 1);
2612 hwc2_error_t err = HWC2_ERROR_NONE;
2613
2614 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, mode, &err));
2615 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code "
2616 << mode;
2617 }
2618 }
2619
2620 /* TESTCASE: Tests that the HWC2 will return unsupported if it does not support
2621 * an optional power mode. */
TEST_F(Hwc2Test,SET_POWER_MODE_unsupported)2622 TEST_F(Hwc2Test, SET_POWER_MODE_unsupported)
2623 {
2624 for (auto display : mDisplays) {
2625 int32_t support = -1;
2626 hwc2_error_t err = HWC2_ERROR_NONE;
2627
2628 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
2629 if (support == 1)
2630 return;
2631
2632 ASSERT_EQ(support, 0) << "invalid doze support value";
2633
2634 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE,
2635 &err));
2636 EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
2637
2638 ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2639 HWC2_POWER_MODE_DOZE_SUSPEND, &err));
2640 EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
2641 }
2642 }
2643
2644 /* TESTCASE: Tests that the HWC2 can set the same power mode multiple times. */
TEST_F(Hwc2Test,SET_POWER_MODE_stress)2645 TEST_F(Hwc2Test, SET_POWER_MODE_stress)
2646 {
2647 for (auto display : mDisplays) {
2648 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2649 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2650
2651 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2652 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2653
2654 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2655 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2656
2657 int32_t support = -1;
2658 ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
2659 if (support != 1)
2660 return;
2661
2662 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
2663 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
2664
2665 ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2666 HWC2_POWER_MODE_DOZE_SUSPEND));
2667 ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2668 HWC2_POWER_MODE_DOZE_SUSPEND));
2669
2670 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2671 }
2672 }
2673
2674 /* TESTCASE: Tests that the HWC2 can enable and disable vsync on active
2675 * displays */
TEST_F(Hwc2Test,SET_VSYNC_ENABLED)2676 TEST_F(Hwc2Test, SET_VSYNC_ENABLED)
2677 {
2678 for (auto display : mDisplays) {
2679 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2680 const_cast<char*>("data"));
2681
2682 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2683
2684 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2685 []() { return; }));
2686
2687 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2688
2689 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2690
2691 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2692 }
2693 }
2694
2695 /* TESTCASE: Tests that the HWC2 issues a valid vsync callback. */
TEST_F(Hwc2Test,SET_VSYNC_ENABLED_callback)2696 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_callback)
2697 {
2698 for (auto display : mDisplays) {
2699 hwc2_display_t receivedDisplay;
2700 int64_t receivedTimestamp;
2701
2702 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2703
2704 ASSERT_NO_FATAL_FAILURE(enableVsync(display));
2705
2706 ASSERT_NO_FATAL_FAILURE(waitForVsync(&receivedDisplay,
2707 &receivedTimestamp));
2708
2709 EXPECT_EQ(receivedDisplay, display) << "failed to get correct display";
2710 EXPECT_GE(receivedTimestamp, 0) << "failed to get valid timestamp";
2711
2712 ASSERT_NO_FATAL_FAILURE(disableVsync(display));
2713
2714 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2715 }
2716 }
2717
2718 /* TESTCASE: Tests that the HWC2 cannot enable a vsync for a bad display */
TEST_F(Hwc2Test,SET_VSYNC_ENABLED_bad_display)2719 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_display)
2720 {
2721 hwc2_display_t display;
2722 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2723 const_cast<char*>("data"));
2724 hwc2_error_t err = HWC2_ERROR_NONE;
2725
2726 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2727
2728 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2729 []() { return; }));
2730
2731 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE, &err));
2732 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2733
2734 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE, &err));
2735 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2736 }
2737
2738 /* TESTCASE: Tests that the HWC2 cannot enable an invalid vsync value */
TEST_F(Hwc2Test,SET_VSYNC_ENABLED_bad_parameter)2739 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_parameter)
2740 {
2741 for (auto display : mDisplays) {
2742 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2743 const_cast<char*>("data"));
2744 hwc2_error_t err = HWC2_ERROR_NONE;
2745
2746 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2747
2748 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2749 []() { return; }));
2750
2751 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_INVALID,
2752 &err));
2753 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
2754
2755 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2756 }
2757 }
2758
2759 /* TESTCASE: Tests that the HWC2 can enable and disable a vsync value multiple
2760 * times. */
TEST_F(Hwc2Test,SET_VSYNC_ENABLED_stress)2761 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_stress)
2762 {
2763 for (auto display : mDisplays) {
2764 hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2765 const_cast<char*>("data"));
2766
2767 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2768
2769 ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2770 []() { return; }));
2771
2772 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2773
2774 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2775 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2776
2777 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2778 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2779
2780 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2781 }
2782 }
2783
2784 /* TESTCASE: Tests that the HWC2 can set a vsync enable value when the display
2785 * is off and no callback is registered. */
TEST_F(Hwc2Test,SET_VSYNC_ENABLED_no_callback_no_power)2786 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback_no_power)
2787 {
2788 const uint secs = 1;
2789
2790 for (auto display : mDisplays) {
2791 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2792
2793 sleep(secs);
2794
2795 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2796 }
2797 }
2798
2799 /* TESTCASE: Tests that the HWC2 can set a vsync enable value when no callback
2800 * is registered. */
TEST_F(Hwc2Test,SET_VSYNC_ENABLED_no_callback)2801 TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback)
2802 {
2803 const uint secs = 1;
2804
2805 for (auto display : mDisplays) {
2806 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2807
2808 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2809
2810 sleep(secs);
2811
2812 ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2813
2814 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2815 }
2816 }
2817
2818 /* TESTCASE: Tests that the HWC2 returns a display name for each display */
TEST_F(Hwc2Test,GET_DISPLAY_NAME)2819 TEST_F(Hwc2Test, GET_DISPLAY_NAME)
2820 {
2821 for (auto display : mDisplays) {
2822 std::string name;
2823
2824 ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name));
2825 }
2826 }
2827
2828 /* TESTCASE: Tests that the HWC2 does not return a display name for a bad
2829 * display */
TEST_F(Hwc2Test,GET_DISPLAY_NAME_bad_display)2830 TEST_F(Hwc2Test, GET_DISPLAY_NAME_bad_display)
2831 {
2832 hwc2_display_t display;
2833 std::string name;
2834 hwc2_error_t err = HWC2_ERROR_NONE;
2835
2836 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2837
2838 ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name, &err));
2839 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2840 }
2841
2842 /* TESTCASE: Tests that the HWC2 can set basic composition types. */
TEST_F(Hwc2Test,SET_LAYER_COMPOSITION_TYPE)2843 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE)
2844 {
2845 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2846 setComposition, advanceComposition));
2847 }
2848
2849 /* TESTCASE: Tests that the HWC2 can update a basic composition type on a
2850 * layer. */
TEST_F(Hwc2Test,SET_LAYER_COMPOSITION_TYPE_update)2851 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_update)
2852 {
2853 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2854 setComposition, advanceComposition));
2855 }
2856
2857 /* TESTCASE: Tests that the HWC2 cannot set a composition type for a bad layer */
TEST_F(Hwc2Test,SET_LAYER_COMPOSITION_TYPE_bad_layer)2858 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_layer)
2859 {
2860 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2861 setComposition));
2862 }
2863
2864 /* TESTCASE: Tests that the HWC2 cannot set a bad composition type */
TEST_F(Hwc2Test,SET_LAYER_COMPOSITION_TYPE_bad_parameter)2865 TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_parameter)
2866 {
2867 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
2868 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
2869 hwc2_error_t* outErr) {
2870
2871 ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,
2872 layer, HWC2_COMPOSITION_INVALID, outErr));
2873 }
2874 ));
2875 }
2876
2877 /* TESTCASE: Tests that the HWC2 can set the cursor position of a layer. */
TEST_F(Hwc2Test,SET_CURSOR_POSITION)2878 TEST_F(Hwc2Test, SET_CURSOR_POSITION)
2879 {
2880 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2881 ::setCursorPosition, advanceCursorPosition));
2882 }
2883
2884 /* TESTCASE: Tests that the HWC2 can update the cursor position of a layer. */
TEST_F(Hwc2Test,SET_CURSOR_POSITION_update)2885 TEST_F(Hwc2Test, SET_CURSOR_POSITION_update)
2886 {
2887 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2888 ::setCursorPosition, advanceCursorPosition));
2889 }
2890
2891 /* TESTCASE: Tests that the HWC2 can set the cursor position of a layer when the
2892 * composition type has not been set to HWC2_COMPOSITION_CURSOR. */
TEST_F(Hwc2Test,SET_CURSOR_POSITION_composition_type_unset)2893 TEST_F(Hwc2Test, SET_CURSOR_POSITION_composition_type_unset)
2894 {
2895 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2896 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
2897 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
2898
2899 const hwc_rect_t cursorPosition = testLayer->getCursorPosition();
2900 EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer,
2901 cursorPosition.left, cursorPosition.top, outErr));
2902 },
2903
2904 advanceCursorPosition));
2905 }
2906
2907 /* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad
2908 * display. */
TEST_F(Hwc2Test,SET_CURSOR_POSITION_bad_display)2909 TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_display)
2910 {
2911 hwc2_display_t display;
2912 hwc2_layer_t layer = 0;
2913 int32_t x = 0, y = 0;
2914 hwc2_error_t err = HWC2_ERROR_NONE;
2915
2916 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2917
2918 ASSERT_NO_FATAL_FAILURE(setCursorPosition(display, layer, x, y, &err));
2919 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2920 }
2921
2922 /* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad layer. */
TEST_F(Hwc2Test,SET_CURSOR_POSITION_bad_layer)2923 TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_layer)
2924 {
2925 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2926 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
2927 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
2928
2929 const hwc_rect_t cursorPosition = testLayer->getCursorPosition();
2930 EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display,
2931 badLayer, cursorPosition.left, cursorPosition.top,
2932 outErr));
2933 }
2934 ));
2935 }
2936
2937 /* TESTCASE: Tests that the HWC2 can set a blend mode value of a layer. */
TEST_F(Hwc2Test,SET_LAYER_BLEND_MODE)2938 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE)
2939 {
2940 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2941 setBlendMode, advanceBlendMode));
2942 }
2943
2944 /* TESTCASE: Tests that the HWC2 can update a blend mode value of a layer. */
TEST_F(Hwc2Test,SET_LAYER_BLEND_MODE_update)2945 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_update)
2946 {
2947 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2948 setBlendMode, advanceBlendMode));
2949 }
2950
2951 /* TESTCASE: Tests that the HWC2 cannot set a blend mode for a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_BLEND_MODE_bad_layer)2952 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_layer)
2953 {
2954 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2955 setBlendMode));
2956 }
2957
2958 /* TESTCASE: Tests that the HWC2 cannot set an invalid blend mode. */
TEST_F(Hwc2Test,SET_LAYER_BLEND_MODE_bad_parameter)2959 TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_parameter)
2960 {
2961 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
2962 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
2963 hwc2_error_t* outErr) {
2964
2965 ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display,
2966 layer, HWC2_BLEND_MODE_INVALID, outErr));
2967 }
2968 ));
2969 }
2970
2971 /* TESTCASE: Tests that the HWC2 can set the buffer of a layer. */
TEST_F(Hwc2Test,SET_LAYER_BUFFER)2972 TEST_F(Hwc2Test, SET_LAYER_BUFFER)
2973 {
2974 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2975 setBuffer, advanceBuffer));
2976 }
2977
2978 /* TESTCASE: Tests that the HWC2 can update the buffer of a layer. */
TEST_F(Hwc2Test,SET_LAYER_BUFFER_update)2979 TEST_F(Hwc2Test, SET_LAYER_BUFFER_update)
2980 {
2981 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2982 setBuffer, advanceBuffer));
2983 }
2984
2985 /* TESTCASE: Tests that the HWC2 cannot set the buffer of a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_BUFFER_bad_layer)2986 TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_layer)
2987 {
2988 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2989 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
2990 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
2991
2992 buffer_handle_t handle = nullptr;
2993 android::base::unique_fd acquireFence;
2994
2995 /* If there is not available buffer for the given buffer
2996 * properties, it should not fail this test case */
2997 if (testLayer->getBuffer(&handle, &acquireFence) == 0) {
2998 *outErr = HWC2_ERROR_BAD_LAYER;
2999 return;
3000 }
3001
3002 ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, badLayer,
3003 handle, acquireFence, outErr));
3004 }
3005 ));
3006 }
3007
3008 /* TESTCASE: Tests that the HWC2 can set an invalid buffer for a layer. */
TEST_F(Hwc2Test,SET_LAYER_BUFFER_bad_parameter)3009 TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_parameter)
3010 {
3011 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
3012 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
3013 hwc2_error_t* outErr) {
3014
3015 buffer_handle_t handle = nullptr;
3016 int32_t acquireFence = -1;
3017
3018 ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer,
3019 handle, acquireFence, outErr));
3020 }
3021 ));
3022 }
3023
3024 /* TESTCASE: Tests that the HWC2 can set the color of a layer. */
TEST_F(Hwc2Test,SET_LAYER_COLOR)3025 TEST_F(Hwc2Test, SET_LAYER_COLOR)
3026 {
3027 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3028 setColor, advanceColor));
3029 }
3030
3031 /* TESTCASE: Tests that the HWC2 can update the color of a layer. */
TEST_F(Hwc2Test,SET_LAYER_COLOR_update)3032 TEST_F(Hwc2Test, SET_LAYER_COLOR_update)
3033 {
3034 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3035 setColor, advanceColor));
3036 }
3037
3038 /* TESTCASE: Tests that the HWC2 can set the color of a layer when the
3039 * composition type has not been set to HWC2_COMPOSITION_SOLID_COLOR. */
TEST_F(Hwc2Test,SET_LAYER_COLOR_composition_type_unset)3040 TEST_F(Hwc2Test, SET_LAYER_COLOR_composition_type_unset)
3041 {
3042 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Basic,
3043 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
3044 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
3045
3046 EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,
3047 testLayer->getColor(), outErr));
3048 },
3049
3050 advanceColor));
3051 }
3052
3053 /* TESTCASE: Tests that the HWC2 cannot set the color of a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_COLOR_bad_layer)3054 TEST_F(Hwc2Test, SET_LAYER_COLOR_bad_layer)
3055 {
3056 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3057 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
3058 Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
3059
3060 EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, badLayer,
3061 testLayer->getColor(), outErr));
3062 }
3063 ));
3064 }
3065
3066 /* TESTCASE: Tests that the HWC2 can set the dataspace of a layer. */
TEST_F(Hwc2Test,SET_LAYER_DATASPACE)3067 TEST_F(Hwc2Test, SET_LAYER_DATASPACE)
3068 {
3069 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3070 setDataspace, advanceDataspace));
3071 }
3072
3073 /* TESTCASE: Tests that the HWC2 can update the dataspace of a layer. */
TEST_F(Hwc2Test,SET_LAYER_DATASPACE_update)3074 TEST_F(Hwc2Test, SET_LAYER_DATASPACE_update)
3075 {
3076 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3077 setDataspace, advanceDataspace));
3078 }
3079
3080 /* TESTCASE: Tests that the HWC2 cannot set a dataspace for a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_DATASPACE_bad_layer)3081 TEST_F(Hwc2Test, SET_LAYER_DATASPACE_bad_layer)
3082 {
3083 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3084 setDataspace));
3085 }
3086
3087 /* TESTCASE: Tests that the HWC2 can set the display frame of a layer. */
TEST_F(Hwc2Test,SET_LAYER_DISPLAY_FRAME)3088 TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME)
3089 {
3090 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3091 setDisplayFrame, advanceDisplayFrame));
3092 }
3093
3094 /* TESTCASE: Tests that the HWC2 can update the display frame of a layer. */
TEST_F(Hwc2Test,SET_LAYER_DISPLAY_FRAME_update)3095 TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_update)
3096 {
3097 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3098 setDisplayFrame, advanceDisplayFrame));
3099 }
3100
3101 /* TESTCASE: Tests that the HWC2 cannot set the display frame of a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_DISPLAY_FRAME_bad_layer)3102 TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_bad_layer)
3103 {
3104 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3105 setDisplayFrame));
3106 }
3107
3108 /* TESTCASE: Tests that the HWC2 can set the plane alpha of a layer. */
TEST_F(Hwc2Test,SET_LAYER_PLANE_ALPHA)3109 TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA)
3110 {
3111 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3112 setPlaneAlpha, advancePlaneAlpha));
3113 }
3114
3115 /* TESTCASE: Tests that the HWC2 can update the plane alpha of a layer. */
TEST_F(Hwc2Test,SET_LAYER_PLANE_ALPHA_update)3116 TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_update)
3117 {
3118 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3119 setPlaneAlpha, advancePlaneAlpha));
3120 }
3121
3122 /* TESTCASE: Tests that the HWC2 cannot set a plane alpha for a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_PLANE_ALPHA_bad_layer)3123 TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_bad_layer)
3124 {
3125 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3126 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
3127 Hwc2TestLayer* testLayer, hwc2_error_t *outErr) {
3128
3129 EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,
3130 badLayer, testLayer->getPlaneAlpha(), outErr));
3131 }
3132 ));
3133 }
3134
3135 /* TESTCASE: Tests that the HWC2 can set the source crop of a layer. */
TEST_F(Hwc2Test,SET_LAYER_SOURCE_CROP)3136 TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP)
3137 {
3138 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3139 setSourceCrop, advanceSourceCrop));
3140 }
3141
3142 /* TESTCASE: Tests that the HWC2 can update the source crop of a layer. */
TEST_F(Hwc2Test,SET_LAYER_SOURCE_CROP_update)3143 TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_update)
3144 {
3145 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3146 setSourceCrop, advanceSourceCrop));
3147 }
3148
3149 /* TESTCASE: Tests that the HWC2 cannot set the source crop of a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_SOURCE_CROP_bad_layer)3150 TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_bad_layer)
3151 {
3152 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3153 setSourceCrop));
3154 }
3155
3156 /* TESTCASE: Tests that the HWC2 can set the surface damage of a layer. */
TEST_F(Hwc2Test,SET_LAYER_SURFACE_DAMAGE)3157 TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE)
3158 {
3159 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3160 setSurfaceDamage, advanceSurfaceDamage));
3161 }
3162
3163 /* TESTCASE: Tests that the HWC2 can update the surface damage of a layer. */
TEST_F(Hwc2Test,SET_LAYER_SURFACE_DAMAGE_update)3164 TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_update)
3165 {
3166 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3167 setSurfaceDamage, advanceSurfaceDamage));
3168 }
3169
3170 /* TESTCASE: Tests that the HWC2 cannot set the surface damage of a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_SURFACE_DAMAGE_bad_layer)3171 TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_bad_layer)
3172 {
3173 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3174 setSurfaceDamage));
3175 }
3176
3177 /* TESTCASE: Tests that the HWC2 can set the transform value of a layer. */
TEST_F(Hwc2Test,SET_LAYER_TRANSFORM)3178 TEST_F(Hwc2Test, SET_LAYER_TRANSFORM)
3179 {
3180 ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3181 setTransform, advanceTransform));
3182 }
3183
3184 /* TESTCASE: Tests that the HWC2 can update the transform value of a layer. */
TEST_F(Hwc2Test,SET_LAYER_TRANSFORM_update)3185 TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_update)
3186 {
3187 ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3188 setTransform, advanceTransform));
3189 }
3190
3191 /* TESTCASE: Tests that the HWC2 cannot set the transform for a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_TRANSFORM_bad_layer)3192 TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_bad_layer)
3193 {
3194 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3195 setTransform));
3196 }
3197
3198 /* TESTCASE: Tests that the HWC2 can set the visible region of a layer. */
TEST_F(Hwc2Test,SET_LAYER_VISIBLE_REGION)3199 TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION)
3200 {
3201 ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Basic, 5,
3202 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
3203 Hwc2TestLayers* testLayers) {
3204
3205 EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display,
3206 layer, testLayers->getVisibleRegion(layer)));
3207 },
3208
3209 advanceVisibleRegions));
3210 }
3211
3212 /* TESTCASE: Tests that the HWC2 cannot set the visible region of a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_VISIBLE_REGION_bad_layer)3213 TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION_bad_layer)
3214 {
3215 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3216 setVisibleRegion));
3217 }
3218
3219 /* TESTCASE: Tests that the HWC2 can set the z order of a layer. */
TEST_F(Hwc2Test,SET_LAYER_Z_ORDER)3220 TEST_F(Hwc2Test, SET_LAYER_Z_ORDER)
3221 {
3222 ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Complete, 10,
3223 [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
3224 Hwc2TestLayers* testLayers) {
3225
3226 EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,
3227 testLayers->getZOrder(layer)));
3228 },
3229
3230 /* TestLayer z orders are set during the construction of TestLayers
3231 * and cannot be updated. There is no need (or ability) to cycle
3232 * through additional z order configurations. */
3233 [] (Hwc2TestLayers* /*testLayers*/) {
3234 return false;
3235 }
3236 ));
3237 }
3238
3239 /* TESTCASE: Tests that the HWC2 can update the z order of a layer. */
TEST_F(Hwc2Test,SET_LAYER_Z_ORDER_update)3240 TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_update)
3241 {
3242 const std::vector<uint32_t> zOrders = { static_cast<uint32_t>(0),
3243 static_cast<uint32_t>(1), static_cast<uint32_t>(UINT32_MAX / 4),
3244 static_cast<uint32_t>(UINT32_MAX / 2),
3245 static_cast<uint32_t>(UINT32_MAX) };
3246
3247 for (auto display : mDisplays) {
3248 std::vector<hwc2_config_t> configs;
3249
3250 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
3251
3252 for (auto config : configs) {
3253 hwc2_layer_t layer;
3254
3255 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
3256
3257 ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
3258
3259 for (uint32_t zOrder : zOrders) {
3260 EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer, zOrder));
3261 }
3262
3263 ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
3264 }
3265 }
3266 }
3267
3268 /* TESTCASE: Tests that the HWC2 cannot set the z order of a bad layer. */
TEST_F(Hwc2Test,SET_LAYER_Z_ORDER_bad_layer)3269 TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_bad_layer)
3270 {
3271 ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3272 setZOrder));
3273 }
3274
3275 /* TESTCASE: Tests that the HWC2 can display a layer with basic property
3276 * coverage */
TEST_F(Hwc2Test,VALIDATE_DISPLAY_basic)3277 TEST_F(Hwc2Test, VALIDATE_DISPLAY_basic)
3278 {
3279 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3280 [] (Hwc2Test* test, hwc2_display_t display,
3281 const std::vector<hwc2_layer_t>& layers,
3282 Hwc2TestLayers* /*testLayers*/) {
3283
3284 uint32_t numTypes, numRequests;
3285 bool hasChanges = false;
3286
3287 EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3288 &numRequests, &hasChanges));
3289 if (hasChanges)
3290 EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size()))
3291 << "wrong number of requests";
3292 }
3293 ));
3294 }
3295
3296 /* TESTCASE: Tests that the HWC2 can display 5 layers with default coverage. */
TEST_F(Hwc2Test,VALIDATE_DISPLAY_default_5)3297 TEST_F(Hwc2Test, VALIDATE_DISPLAY_default_5)
3298 {
3299 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 5,
3300 [] (Hwc2Test* test, hwc2_display_t display,
3301 const std::vector<hwc2_layer_t>& layers,
3302 Hwc2TestLayers* /*testLayers*/) {
3303
3304 uint32_t numTypes, numRequests;
3305 bool hasChanges = false;
3306
3307 EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3308 &numRequests, &hasChanges));
3309 if (hasChanges)
3310 EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size()))
3311 << "wrong number of requests";
3312 }
3313 ));
3314 }
3315
3316 /* TESTCASE: Tests that the HWC2 cannot validate a bad display */
TEST_F(Hwc2Test,VALIDATE_DISPLAY_bad_display)3317 TEST_F(Hwc2Test, VALIDATE_DISPLAY_bad_display)
3318 {
3319 hwc2_display_t display;
3320 uint32_t numTypes, numRequests;
3321 hwc2_error_t err = HWC2_ERROR_NONE;
3322
3323 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3324
3325 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, &numRequests,
3326 &err));
3327 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3328 }
3329
3330 /* TESTCASE: Tests that the HWC2 can get display requests after validating a
3331 * basic layer. */
TEST_F(Hwc2Test,GET_DISPLAY_REQUESTS_basic)3332 TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_basic)
3333 {
3334 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3335 [] (Hwc2Test* test, hwc2_display_t display,
3336 const std::vector<hwc2_layer_t>& layers,
3337 Hwc2TestLayers* /*testLayers*/) {
3338
3339 uint32_t numTypes, numRequests;
3340 bool hasChanges = false;
3341
3342 ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3343 &numRequests, &hasChanges));
3344 if (hasChanges)
3345 EXPECT_LE(numTypes, layers.size())
3346 << "wrong number of requests";
3347
3348 EXPECT_NO_FATAL_FAILURE(test->handleRequests(display, layers,
3349 numRequests));
3350 }
3351 ));
3352 }
3353
3354 /* TESTCASE: Tests that the HWC2 cannot get display requests from a bad display */
TEST_F(Hwc2Test,GET_DISPLAY_REQUESTS_bad_display)3355 TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_bad_display)
3356 {
3357 hwc2_display_t display;
3358 hwc2_display_request_t displayRequests;
3359 std::vector<hwc2_layer_t> layers;
3360 std::vector<hwc2_layer_request_t> layerRequests;
3361 hwc2_error_t err = HWC2_ERROR_NONE;
3362
3363 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3364
3365 EXPECT_NO_FATAL_FAILURE(getDisplayRequests(display, &displayRequests,
3366 &layers, &layerRequests, &err));
3367 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3368 }
3369
3370 /* TESTCASE: Tests that the HWC2 cannot get display requests from an non
3371 * validated display. */
TEST_F(Hwc2Test,GET_DISPLAY_REQUESTS_not_validated)3372 TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_not_validated)
3373 {
3374 ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5,
3375 [] (Hwc2Test* test, hwc2_display_t display,
3376 std::vector<hwc2_layer_t>* layers) {
3377
3378 hwc2_display_request_t displayRequests;
3379 std::vector<hwc2_layer_request_t> layerRequests;
3380 hwc2_error_t err = HWC2_ERROR_NONE;
3381
3382 ASSERT_NO_FATAL_FAILURE(test->getDisplayRequests(display,
3383 &displayRequests, layers, &layerRequests, &err));
3384 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
3385 << "returned wrong error code";
3386 }
3387 ));
3388 }
3389
3390 /* TESTCASE: Tests that the HWC2 can get changed composition types after
3391 * validating a basic layer. */
TEST_F(Hwc2Test,GET_CHANGED_COMPOSITION_TYPES_basic)3392 TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_basic)
3393 {
3394 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3395 [] (Hwc2Test* test, hwc2_display_t display,
3396 const std::vector<hwc2_layer_t>& layers,
3397 Hwc2TestLayers* testLayers) {
3398
3399 uint32_t numTypes, numRequests;
3400 bool hasChanges = false;
3401
3402 ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3403 &numRequests, &hasChanges));
3404 if (hasChanges)
3405 EXPECT_LE(numTypes, layers.size())
3406 << "wrong number of requests";
3407
3408 EXPECT_NO_FATAL_FAILURE(test->handleCompositionChanges(display,
3409 *testLayers, layers, numTypes));
3410 }
3411 ));
3412 }
3413
3414 /* TESTCASE: Tests that the HWC2 cannot get changed composition types from a bad
3415 * display */
TEST_F(Hwc2Test,GET_CHANGED_COMPOSITION_TYPES_bad_display)3416 TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_bad_display)
3417 {
3418 hwc2_display_t display;
3419 std::vector<hwc2_layer_t> layers;
3420 std::vector<hwc2_composition_t> types;
3421 hwc2_error_t err = HWC2_ERROR_NONE;
3422
3423 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3424
3425 EXPECT_NO_FATAL_FAILURE(getChangedCompositionTypes(display, &layers,
3426 &types, &err));
3427 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3428 }
3429
3430 /* TESTCASE: Tests that the HWC2 cannot get changed composition types from an non
3431 * validated display. */
TEST_F(Hwc2Test,GET_CHANGED_COMPOSITION_TYPES_not_validated)3432 TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_not_validated)
3433 {
3434 ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5,
3435 [] (Hwc2Test* test, hwc2_display_t display,
3436 std::vector<hwc2_layer_t>* layers) {
3437
3438 std::vector<hwc2_composition_t> types;
3439 hwc2_error_t err = HWC2_ERROR_NONE;
3440
3441 ASSERT_NO_FATAL_FAILURE(test->getChangedCompositionTypes(
3442 display, layers, &types, &err));
3443 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
3444 << "returned wrong error code";
3445 }
3446 ));
3447 }
3448
3449 /* TESTCASE: Tests that the HWC2 can accept display changes after validating a
3450 * basic layer. */
TEST_F(Hwc2Test,ACCEPT_DISPLAY_CHANGES_basic)3451 TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_basic)
3452 {
3453 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3454 [] (Hwc2Test* test, hwc2_display_t display,
3455 const std::vector<hwc2_layer_t>& layers,
3456 Hwc2TestLayers* testLayers) {
3457
3458 uint32_t numTypes, numRequests;
3459 bool hasChanges = false;
3460
3461 ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3462 &numRequests, &hasChanges));
3463 if (hasChanges)
3464 EXPECT_LE(numTypes, layers.size())
3465 << "wrong number of requests";
3466
3467 ASSERT_NO_FATAL_FAILURE(test->handleCompositionChanges(display,
3468 *testLayers, layers, numTypes));
3469
3470 EXPECT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display));
3471 }
3472 ));
3473 }
3474
3475 /* TESTCASE: Tests that the HWC2 cannot accept display changes from a bad
3476 * display */
TEST_F(Hwc2Test,ACCEPT_DISPLAY_CHANGES_bad_display)3477 TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_bad_display)
3478 {
3479 hwc2_display_t display;
3480 hwc2_error_t err = HWC2_ERROR_NONE;
3481
3482 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3483
3484 EXPECT_NO_FATAL_FAILURE(acceptDisplayChanges(display, &err));
3485 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3486 }
3487
3488 /* TESTCASE: Tests that the HWC2 cannot accept display changes from an non
3489 * validated display. */
TEST_F(Hwc2Test,ACCEPT_DISPLAY_CHANGES_not_validated)3490 TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_not_validated)
3491 {
3492 ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5,
3493 [] (Hwc2Test* test, hwc2_display_t display,
3494 std::vector<hwc2_layer_t>* /*layers*/) {
3495
3496 hwc2_error_t err = HWC2_ERROR_NONE;
3497
3498 ASSERT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display, &err));
3499 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
3500 << "returned wrong error code";
3501 }
3502 ));
3503 }
3504
3505 /* TESTCASE: Tests that the HWC2 supports client target with required values */
TEST_F(Hwc2Test,GET_CLIENT_TARGET_SUPPORT)3506 TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT)
3507 {
3508 ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default,
3509 [] (Hwc2Test* test, hwc2_display_t display,
3510 const Hwc2TestClientTargetSupport& testClientTargetSupport) {
3511
3512 const Area bufferArea = testClientTargetSupport.getBufferArea();
3513 const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888;
3514
3515 ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display,
3516 bufferArea.width, bufferArea.height, format,
3517 testClientTargetSupport.getDataspace()));
3518 },
3519
3520 advanceClientTargetSupport));
3521 }
3522
3523 /* TESTCASE: Tests that the HWC2 cannot get client target support for a bad
3524 * display. */
TEST_F(Hwc2Test,GET_CLIENT_TARGET_SUPPORT_bad_display)3525 TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_bad_display)
3526 {
3527 ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default,
3528 [] (Hwc2Test* test, hwc2_display_t /*display*/,
3529 const Hwc2TestClientTargetSupport& testClientTargetSupport) {
3530
3531 const Area bufferArea = testClientTargetSupport.getBufferArea();
3532 const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888;
3533 hwc2_display_t badDisplay;
3534 hwc2_error_t err = HWC2_ERROR_NONE;
3535
3536 ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay));
3537
3538 ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(badDisplay,
3539 bufferArea.width, bufferArea.height, format,
3540 testClientTargetSupport.getDataspace(), &err));
3541 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3542 },
3543
3544 advanceClientTargetSupport));
3545 }
3546
3547 /* TESTCASE: Tests that the HWC2 either supports or returns error unsupported
3548 * for a variety of client target values. */
TEST_F(Hwc2Test,GET_CLIENT_TARGET_SUPPORT_unsupported)3549 TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_unsupported)
3550 {
3551 ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Complete,
3552 [] (Hwc2Test* test, hwc2_display_t display,
3553 const Hwc2TestClientTargetSupport& testClientTargetSupport) {
3554
3555 const Area bufferArea = testClientTargetSupport.getBufferArea();
3556 const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888;
3557 hwc2_error_t err = HWC2_ERROR_NONE;
3558
3559 ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display,
3560 bufferArea.width, bufferArea.height, format,
3561 testClientTargetSupport.getDataspace(), &err));
3562 EXPECT_TRUE(err == HWC2_ERROR_NONE
3563 || err == HWC2_ERROR_UNSUPPORTED)
3564 << "returned wrong error code";
3565 },
3566
3567 advanceClientTargetSupport));
3568 }
3569
3570 /* TESTCASE: Tests that the HWC2 can set a client target buffer for a basic
3571 * layer. */
TEST_F(Hwc2Test,SET_CLIENT_TARGET_basic)3572 TEST_F(Hwc2Test, SET_CLIENT_TARGET_basic)
3573 {
3574 const android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN;
3575 const hwc_region_t damage = { };
3576 const size_t layerCnt = 1;
3577
3578 for (auto display : mDisplays) {
3579 std::vector<hwc2_config_t> configs;
3580
3581 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
3582
3583 ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
3584
3585 for (auto config : configs) {
3586 Area displayArea;
3587 std::vector<hwc2_layer_t> layers;
3588
3589 ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
3590 ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea));
3591
3592 ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
3593 Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Basic,
3594 displayArea);
3595
3596 if (!testLayers.optimizeLayouts())
3597 continue;
3598
3599 Hwc2TestClientTarget testClientTarget;
3600
3601 do {
3602 std::set<hwc2_layer_t> clientLayers;
3603 std::set<hwc2_layer_t> clearLayers;
3604 uint32_t numTypes, numRequests;
3605 bool hasChanges, skip;
3606 bool flipClientTarget;
3607 buffer_handle_t handle;
3608 int32_t acquireFence;
3609
3610 ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers,
3611 &testLayers, &skip));
3612 if (skip)
3613 continue;
3614
3615 ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes,
3616 &numRequests, &hasChanges));
3617 if (hasChanges)
3618 EXPECT_LE(numTypes, layers.size())
3619 << "wrong number of requests";
3620
3621 ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display,
3622 testLayers, layers, numTypes, &clientLayers));
3623 ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers,
3624 numRequests, &clearLayers, &flipClientTarget));
3625 ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers,
3626 clearLayers, flipClientTarget, displayArea, &handle,
3627 &acquireFence), 0);
3628 EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle,
3629 acquireFence, dataspace, damage));
3630
3631 if (acquireFence >= 0)
3632 close(acquireFence);
3633
3634 } while (testLayers.advance());
3635
3636 ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
3637 }
3638
3639 ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
3640 }
3641 }
3642
3643 /* TESTCASE: Tests that the HWC2 cannot set a client target for a bad display. */
TEST_F(Hwc2Test,SET_CLIENT_TARGET_bad_display)3644 TEST_F(Hwc2Test, SET_CLIENT_TARGET_bad_display)
3645 {
3646 hwc2_display_t display;
3647 std::vector<hwc2_layer_t> layers;
3648 const Area displayArea = {0, 0};
3649 Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Default, displayArea);
3650 std::set<hwc2_layer_t> clientLayers;
3651 std::set<hwc2_layer_t> flipClientTargetLayers;
3652 bool flipClientTarget = true;
3653 const android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN;
3654 const hwc_region_t damage = { };
3655 buffer_handle_t handle;
3656 int32_t acquireFence;
3657 hwc2_error_t err = HWC2_ERROR_NONE;
3658
3659 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3660
3661 Hwc2TestClientTarget testClientTarget;
3662
3663 ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers,
3664 flipClientTargetLayers, flipClientTarget, displayArea, &handle,
3665 &acquireFence), 0);
3666
3667 EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence,
3668 dataspace, damage, &err));
3669
3670 if (acquireFence >= 0)
3671 close(acquireFence);
3672
3673 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3674 }
3675
3676 /* TESTCASE: Tests that the HWC2 can present 1 default layer. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_default_1)3677 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_1)
3678 {
3679 const size_t layerCnt = 1;
3680 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3681 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3682 bool optimize = false;
3683
3684 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3685 optimize));
3686 }
3687
3688 /* TESTCASE: Tests that the HWC2 can present 2 default layers. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_default_2)3689 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_2)
3690 {
3691 const size_t layerCnt = 2;
3692 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3693 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3694 bool optimize = false;
3695
3696 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3697 optimize));
3698 }
3699
3700 /* TESTCASE: Tests that the HWC2 can present 3 default layers. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_default_3)3701 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_3)
3702 {
3703 const size_t layerCnt = 3;
3704 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3705 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3706 bool optimize = false;
3707
3708 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3709 optimize));
3710 }
3711
3712 /* TESTCASE: Tests that the HWC2 can present 4 default layers. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_default_4)3713 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_4)
3714 {
3715 const size_t layerCnt = 4;
3716 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3717 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3718 bool optimize = false;
3719
3720 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3721 optimize));
3722 }
3723
3724 /* TESTCASE: Tests that the HWC2 can present 5 default layers. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_default_5)3725 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_5)
3726 {
3727 const size_t layerCnt = 5;
3728 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3729 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3730 bool optimize = false;
3731
3732 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3733 optimize));
3734 }
3735
3736 /* TESTCASE: Tests that the HWC2 can present 6 default layers. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_default_6)3737 TEST_F(Hwc2Test, PRESENT_DISPLAY_default_6)
3738 {
3739 const size_t layerCnt = 6;
3740 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3741 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3742 bool optimize = false;
3743
3744 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3745 optimize));
3746 }
3747
3748 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3749 * blend mode. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_blend_mode_1)3750 TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_1)
3751 {
3752 const size_t layerCnt = 1;
3753 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3754 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3755 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete},
3756 {Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Basic},
3757 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}};
3758 bool optimize = false;
3759
3760 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3761 optimize));
3762 }
3763
3764 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3765 * blend mode. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_blend_mode_2)3766 TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_2)
3767 {
3768 const size_t layerCnt = 2;
3769 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3770 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3771 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete},
3772 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}};
3773 bool optimize = false;
3774
3775 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3776 optimize));
3777 }
3778
3779 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3780 * buffer. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_buffer_1)3781 TEST_F(Hwc2Test, PRESENT_DISPLAY_buffer_1)
3782 {
3783 const size_t layerCnt = 1;
3784 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3785 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3786 {{Hwc2TestPropertyName::BufferArea, Hwc2TestCoverage::Complete}};
3787 bool optimize = true;
3788
3789 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3790 optimize));
3791 }
3792
3793 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3794 * color. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_color_1)3795 TEST_F(Hwc2Test, PRESENT_DISPLAY_color_1)
3796 {
3797 const size_t layerCnt = 1;
3798 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3799 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3800 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3801 {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Complete}};
3802 bool optimize = true;
3803
3804 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3805 optimize));
3806 }
3807
3808 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3809 * color. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_color_2)3810 TEST_F(Hwc2Test, PRESENT_DISPLAY_color_2)
3811 {
3812 const size_t layerCnt = 2;
3813 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3814 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3815 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3816 {Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic},
3817 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic},
3818 {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Basic}};
3819 bool optimize = true;
3820
3821 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3822 optimize));
3823 }
3824
3825 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3826 * composition. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_composition_1)3827 TEST_F(Hwc2Test, PRESENT_DISPLAY_composition_1)
3828 {
3829 const size_t layerCnt = 1;
3830 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3831 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3832 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}};
3833 bool optimize = true;
3834
3835 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3836 optimize));
3837 }
3838
3839 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3840 * cursor. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_cursor_1)3841 TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_1)
3842 {
3843 const size_t layerCnt = 1;
3844 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3845 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3846 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3847 {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete}};
3848 bool optimize = true;
3849
3850 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3851 optimize));
3852 }
3853
3854 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3855 * cursor. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_cursor_2)3856 TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_2)
3857 {
3858 const size_t layerCnt = 2;
3859 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3860 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3861 {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3862 {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete},
3863 {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}};
3864 bool optimize = true;
3865
3866 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3867 optimize));
3868 }
3869
3870 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3871 * dataspace. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_dataspace_1)3872 TEST_F(Hwc2Test, PRESENT_DISPLAY_dataspace_1)
3873 {
3874 const size_t layerCnt = 1;
3875 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3876 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3877 {{Hwc2TestPropertyName::Dataspace, Hwc2TestCoverage::Complete}};
3878 bool optimize = true;
3879
3880 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3881 optimize));
3882 }
3883
3884 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3885 * display frame. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_display_frame_1)3886 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_1)
3887 {
3888 const size_t layerCnt = 1;
3889 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3890 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3891 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3892 bool optimize = true;
3893
3894 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3895 optimize));
3896 }
3897
3898 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3899 * display frame. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_display_frame_2)3900 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_2)
3901 {
3902 const size_t layerCnt = 2;
3903 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3904 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3905 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3906 bool optimize = true;
3907
3908 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3909 optimize));
3910 }
3911
3912 /* TESTCASE: Tests that the HWC2 can present 3 layers with complete coverage of
3913 * display frame. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_display_frame_3)3914 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_3)
3915 {
3916 const size_t layerCnt = 3;
3917 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3918 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3919 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3920 bool optimize = true;
3921
3922 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3923 optimize));
3924 }
3925
3926 /* TESTCASE: Tests that the HWC2 can present 4 layers with complete coverage of
3927 * display frame. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_display_frame_4)3928 TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_4)
3929 {
3930 const size_t layerCnt = 4;
3931 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3932 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3933 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3934 bool optimize = true;
3935
3936 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3937 optimize));
3938 }
3939
3940 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3941 * plane alpha. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_plane_alpha_1)3942 TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_1)
3943 {
3944 const size_t layerCnt = 1;
3945 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3946 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3947 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic},
3948 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}};
3949 bool optimize = false;
3950
3951 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3952 optimize));
3953 }
3954
3955 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3956 * plane alpha. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_plane_alpha_2)3957 TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_2)
3958 {
3959 const size_t layerCnt = 2;
3960 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3961 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3962 {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic},
3963 {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}};
3964 bool optimize = false;
3965
3966 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3967 optimize));
3968 }
3969
3970 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3971 * source crop. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_source_crop_1)3972 TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_1)
3973 {
3974 const size_t layerCnt = 1;
3975 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3976 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3977 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete},
3978 {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}};
3979 bool optimize = true;
3980
3981 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3982 optimize));
3983 }
3984
3985 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3986 * source crop. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_source_crop_2)3987 TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_2)
3988 {
3989 const size_t layerCnt = 2;
3990 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3991 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3992 {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete},
3993 {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}};
3994 bool optimize = true;
3995
3996 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3997 optimize));
3998 }
3999
4000
4001 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
4002 * surface damage. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_surface_damage_1)4003 TEST_F(Hwc2Test, PRESENT_DISPLAY_surface_damage_1)
4004 {
4005 const size_t layerCnt = 1;
4006 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
4007 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
4008 {{Hwc2TestPropertyName::SurfaceDamage, Hwc2TestCoverage::Complete}};
4009 bool optimize = true;
4010
4011 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
4012 optimize));
4013 }
4014
4015 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
4016 * transform. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_transform_1)4017 TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_1)
4018 {
4019 const size_t layerCnt = 1;
4020 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
4021 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
4022 {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete}};
4023 bool optimize = true;
4024
4025 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
4026 optimize));
4027 }
4028
4029 /* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
4030 * transform. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_transform_2)4031 TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_2)
4032 {
4033 const size_t layerCnt = 2;
4034 Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
4035 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
4036 {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete},
4037 {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}};
4038 bool optimize = true;
4039
4040 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
4041 optimize));
4042 }
4043
4044 /* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
4045 * basic. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_basic_1)4046 TEST_F(Hwc2Test, PRESENT_DISPLAY_basic_1)
4047 {
4048 const size_t layerCnt = 1;
4049 Hwc2TestCoverage coverage = Hwc2TestCoverage::Basic;
4050 std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
4051 bool optimize = true;
4052
4053 ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
4054 optimize));
4055 }
4056
4057 /* TESTCASE: Tests that the HWC2 cannot present a bad display. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_bad_display)4058 TEST_F(Hwc2Test, PRESENT_DISPLAY_bad_display)
4059 {
4060 hwc2_display_t display;
4061 int32_t presentFence;
4062 hwc2_error_t err = HWC2_ERROR_NONE;
4063
4064 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4065
4066 ASSERT_NO_FATAL_FAILURE(presentDisplay(display, &presentFence, &err));
4067 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4068 }
4069
4070 /* TESTCASE: Tests that the HWC2 cannot present an unvalidated display. */
TEST_F(Hwc2Test,PRESENT_DISPLAY_not_validated)4071 TEST_F(Hwc2Test, PRESENT_DISPLAY_not_validated)
4072 {
4073 ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 1,
4074 [] (Hwc2Test* test, hwc2_display_t display,
4075 const std::vector<hwc2_layer_t>& /*layers*/,
4076 Hwc2TestLayers* /*testLayers*/) {
4077
4078 int32_t presentFence;
4079 hwc2_error_t err = HWC2_ERROR_NONE;
4080
4081 ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display,
4082 HWC2_POWER_MODE_ON));
4083 ASSERT_NO_FATAL_FAILURE(test->enableVsync(display));
4084
4085 ASSERT_NO_FATAL_FAILURE(test->waitForVsync());
4086
4087 ASSERT_NO_FATAL_FAILURE(test->presentDisplay(display,
4088 &presentFence, &err));
4089 EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
4090 << "returned wrong error code";
4091
4092 ASSERT_NO_FATAL_FAILURE(test->disableVsync(display));
4093 ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display,
4094 HWC2_POWER_MODE_OFF));
4095 }
4096 ));
4097 }
4098
4099 /* TESTCASE: Tests that the HWC2 cannot get release fences from a bad display. */
TEST_F(Hwc2Test,GET_RELEASE_FENCES_bad_display)4100 TEST_F(Hwc2Test, GET_RELEASE_FENCES_bad_display)
4101 {
4102 hwc2_display_t display;
4103 std::vector<hwc2_layer_t> layers;
4104 std::vector<int32_t> fences;
4105 hwc2_error_t err = HWC2_ERROR_NONE;
4106
4107 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4108
4109 ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences, &err));
4110 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4111 }
4112
4113 static const std::array<android_color_mode, 9> androidColorModes = {{
4114 HAL_COLOR_MODE_NATIVE,
4115 HAL_COLOR_MODE_STANDARD_BT601_625,
4116 HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED,
4117 HAL_COLOR_MODE_STANDARD_BT601_525,
4118 HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED,
4119 HAL_COLOR_MODE_STANDARD_BT709,
4120 HAL_COLOR_MODE_DCI_P3,
4121 HAL_COLOR_MODE_SRGB,
4122 HAL_COLOR_MODE_ADOBE_RGB,
4123 }};
4124
4125 /* TESTCASE: Tests that the HWC2 can get the color modes for a display. The
4126 * display must support HAL_COLOR_MODE_NATIVE */
TEST_F(Hwc2Test,GET_COLOR_MODES)4127 TEST_F(Hwc2Test, GET_COLOR_MODES)
4128 {
4129 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4130 [] (Hwc2Test* test, hwc2_display_t display) {
4131
4132 std::vector<android_color_mode_t> colorModes;
4133
4134 ASSERT_NO_FATAL_FAILURE(test->getColorModes(display,
4135 &colorModes));
4136
4137 EXPECT_NE(std::count(colorModes.begin(), colorModes.end(),
4138 HAL_COLOR_MODE_NATIVE), 0) << "all displays"
4139 " must support HAL_COLOR_MODE_NATIVE";
4140 }
4141 ));
4142 }
4143
4144 /* TESTCASE: Tests that the HWC2 cannot get color modes from a bad display. */
TEST_F(Hwc2Test,GET_COLOR_MODES_bad_display)4145 TEST_F(Hwc2Test, GET_COLOR_MODES_bad_display)
4146 {
4147 hwc2_display_t display;
4148 std::vector<android_color_mode_t> colorModes;
4149 hwc2_error_t err = HWC2_ERROR_NONE;
4150
4151 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4152
4153 ASSERT_NO_FATAL_FAILURE(getColorModes(display, &colorModes, &err));
4154 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4155 }
4156
4157 /* TESTCASE: Tests that the HWC2 can set the required color mode on a display. */
TEST_F(Hwc2Test,SET_COLOR_MODES)4158 TEST_F(Hwc2Test, SET_COLOR_MODES)
4159 {
4160 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4161 [] (Hwc2Test* test, hwc2_display_t display) {
4162
4163 const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE;
4164
4165 EXPECT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode));
4166 }
4167 ));
4168 }
4169
4170 /* TESTCASE: Tests that the HWC2 cannot set a color mode on a bad display. */
TEST_F(Hwc2Test,SET_COLOR_MODES_bad_display)4171 TEST_F(Hwc2Test, SET_COLOR_MODES_bad_display)
4172 {
4173 hwc2_display_t display;
4174 const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE;
4175 hwc2_error_t err = HWC2_ERROR_NONE;
4176
4177 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4178
4179 ASSERT_NO_FATAL_FAILURE(setColorMode(display, colorMode, &err));
4180 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4181 }
4182
4183 /* TESTCASE: Tests that the HWC2 cannot set an invalid color mode. */
TEST_F(Hwc2Test,SET_COLOR_MODES_bad_parameter)4184 TEST_F(Hwc2Test, SET_COLOR_MODES_bad_parameter)
4185 {
4186 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4187 [] (Hwc2Test* test, hwc2_display_t display) {
4188
4189 const android_color_mode_t colorMode =
4190 static_cast<android_color_mode_t>(-1);
4191 hwc2_error_t err = HWC2_ERROR_NONE;
4192
4193 ASSERT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode,
4194 &err));
4195 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER)
4196 << "returned wrong error code";
4197 }
4198 ));
4199 }
4200
4201 /* TESTCASE: Tests that the HWC2 either supports or returns error unsupported
4202 * for all valid color modes. */
TEST_F(Hwc2Test,SET_COLOR_MODES_unsupported)4203 TEST_F(Hwc2Test, SET_COLOR_MODES_unsupported)
4204 {
4205 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4206 [] (Hwc2Test* test, hwc2_display_t display) {
4207
4208 for (auto colorMode : androidColorModes) {
4209 hwc2_error_t err = HWC2_ERROR_NONE;
4210
4211 ASSERT_NO_FATAL_FAILURE(test->setColorMode(display,
4212 colorMode, &err));
4213
4214 EXPECT_TRUE(err == HWC2_ERROR_NONE
4215 || err == HWC2_ERROR_UNSUPPORTED)
4216 << "returned wrong error code";
4217 }
4218 }
4219 ));
4220 }
4221
4222 /* TESTCASE: Tests that the HWC2 gets the HDR capabilities for a display and
4223 * test if they are valid. */
TEST_F(Hwc2Test,GET_HDR_CAPABILITIES)4224 TEST_F(Hwc2Test, GET_HDR_CAPABILITIES)
4225 {
4226 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4227 [] (Hwc2Test* test, hwc2_display_t display) {
4228
4229 std::vector<android_hdr_t> hdrCapabilities;
4230 float maxLuminance, maxAverageLuminance, minLuminance;
4231
4232 EXPECT_NO_FATAL_FAILURE(test->getHdrCapabilities(display,
4233 &hdrCapabilities, &maxLuminance, &maxAverageLuminance,
4234 &minLuminance));
4235
4236 if (hdrCapabilities.empty())
4237 return;
4238
4239 EXPECT_GE(maxLuminance, maxAverageLuminance);
4240 EXPECT_GE(maxAverageLuminance, minLuminance);
4241 }
4242 ));
4243 }
4244
4245 /* TESTCASE: Tests that the HWC2 cannot get hdr capabilities from a bad display */
TEST_F(Hwc2Test,GET_HDR_CAPABILITIES_bad_display)4246 TEST_F(Hwc2Test, GET_HDR_CAPABILITIES_bad_display)
4247 {
4248 hwc2_display_t display;
4249 std::vector<android_hdr_t> hdrCapabilities;
4250 float maxLuminance, maxAverageLuminance, minLuminance;
4251 hwc2_error_t err = HWC2_ERROR_NONE;
4252
4253 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4254
4255 ASSERT_NO_FATAL_FAILURE(getHdrCapabilities(display, &hdrCapabilities,
4256 &maxLuminance, &maxAverageLuminance, &minLuminance, &err));
4257 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4258 }
4259
4260 static const std::array<float, 16> identityMatrix = {{
4261 1.0, 0.0, 0.0, 0.0,
4262 0.0, 1.0, 0.0, 0.0,
4263 0.0, 0.0, 1.0, 0.0,
4264 0.0, 0.0, 0.0, 1.0,
4265 }};
4266
4267 /* Values for the color transform matrices were precomputed using the source code
4268 * in surfaceflinger/Effects/Daltonizer.cpp. */
4269
4270 static const std::array<const std::array<float, 16>, 5> exampleMatrices = {{
4271 identityMatrix,
4272 /* Converts RGB color to the XYZ space */
4273 {{ 0.4124, 0.2126, 0.0193, 0,
4274 0.3576, 0.7152, 0.1192, 0,
4275 0.1805, 0.0722, 0.9505, 0,
4276 0 , 0 , 0 , 1 }},
4277 /* Protanomaly */
4278 {{ 0.068493, 0.931506, 0, 0,
4279 0.068493, 0.931507, 0, 0,
4280 0.013626, -0.013626, 1, 0,
4281 0, 0, 0, 1 }},
4282 /* Deuteranomaly */
4283 {{ 0.288299, 0.711701, 0, 0,
4284 0.052709, 0.947291, 0, 0,
4285 -0.257912, 0.257912, 1, 0,
4286 0, 0, 0, 1 }},
4287 /* Tritanomaly */
4288 {{ 1, -0.805712, 0.805712, 0,
4289 0, 0.378838, 0.621162, 0,
4290 0, 0.104823, 0.895177, 0,
4291 0, 0, 0, 1 }},
4292 }};
4293
4294 /* TESTCASE: Tests that the HWC2 can set the identity color transform */
TEST_F(Hwc2Test,SET_COLOR_TRANSFORM)4295 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM)
4296 {
4297 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4298 [] (Hwc2Test* test, hwc2_display_t display) {
4299
4300 EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display,
4301 identityMatrix, HAL_COLOR_TRANSFORM_IDENTITY));
4302 }
4303 ));
4304 }
4305
4306 /* TESTCASE: Tests that the HWC2 cannot set the color transform for a bad
4307 * display. */
TEST_F(Hwc2Test,SET_COLOR_TRANSFORM_bad_display)4308 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_display)
4309 {
4310 hwc2_display_t display;
4311 hwc2_error_t err = HWC2_ERROR_NONE;
4312
4313 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4314
4315 ASSERT_NO_FATAL_FAILURE(setColorTransform(display, identityMatrix,
4316 HAL_COLOR_TRANSFORM_IDENTITY, &err));
4317 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4318 }
4319
4320 /* TESTCASE: Tests that the HWC2 cannot set an invalid color transform. */
TEST_F(Hwc2Test,SET_COLOR_TRANSFORM_bad_parameter)4321 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_parameter)
4322 {
4323 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4324 [] (Hwc2Test* test, hwc2_display_t display) {
4325
4326 const android_color_transform_t hint =
4327 static_cast<android_color_transform_t>(-1);
4328 hwc2_error_t err = HWC2_ERROR_NONE;
4329
4330 ASSERT_NO_FATAL_FAILURE(test->setColorTransform(display,
4331 identityMatrix, hint, &err));
4332 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER)
4333 << "returned wrong error code";
4334 }
4335 ));
4336 }
4337
4338 /* TESTCASE: Tests that the HWC2 can set an arbitrary color matrix. */
TEST_F(Hwc2Test,SET_COLOR_TRANSFORM_arbitrary_matrix)4339 TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_arbitrary_matrix)
4340 {
4341 ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4342 [] (Hwc2Test* test, hwc2_display_t display) {
4343
4344 const android_color_transform_t hint =
4345 HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX;
4346
4347 for (const std::array<float, 16>& matrix : exampleMatrices) {
4348 EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display,
4349 matrix, hint));
4350 }
4351 }
4352 ));
4353 }
4354
4355 /* TESTCASE: Tests that the HWC2 create an destory virtual displays. */
TEST_F(Hwc2Test,CREATE_DESTROY_VIRTUAL_DISPLAY)4356 TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY)
4357 {
4358 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete,
4359 [] (Hwc2Test* /*test*/, hwc2_display_t /*display*/,
4360 Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) { }));
4361 }
4362
4363 /* TESTCASE: Tests that the HWC2 can create and destroy multiple virtual
4364 * displays. */
TEST_F(Hwc2Test,CREATE_DESTROY_VIRTUAL_DISPLAY_multiple)4365 TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY_multiple)
4366 {
4367 Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete);
4368 std::vector<hwc2_display_t> displays;
4369
4370 do {
4371 const UnsignedArea& dimension =
4372 testVirtualDisplay.getDisplayDimension();
4373 android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888;
4374 hwc2_display_t display;
4375 hwc2_error_t err = HWC2_ERROR_NONE;
4376
4377 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width,
4378 dimension.height, &desiredFormat, &display, &err));
4379
4380 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES
4381 || err == HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
4382 EXPECT_GE(desiredFormat, 0) << "invalid format";
4383
4384 if (err == HWC2_ERROR_NONE)
4385 displays.push_back(display);
4386
4387 } while (testVirtualDisplay.advance());
4388
4389 for (hwc2_display_t display : displays) {
4390 EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display));
4391 }
4392 }
4393
4394 /* TESTCASE: Tests that the HWC2 cannot destroy a bad virtual displays. */
TEST_F(Hwc2Test,DESTROY_VIRTUAL_DISPLAY_bad_display)4395 TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_display)
4396 {
4397 hwc2_display_t display;
4398 hwc2_error_t err = HWC2_ERROR_NONE;
4399
4400 ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4401
4402 ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err));
4403 EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4404 }
4405
4406 /* TESTCASE: Tests that the HWC2 cannot destroy a physical display. */
TEST_F(Hwc2Test,DESTROY_VIRTUAL_DISPLAY_bad_parameter)4407 TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_parameter)
4408 {
4409 hwc2_display_t display = HWC_DISPLAY_PRIMARY;
4410 hwc2_error_t err = HWC2_ERROR_NONE;
4411
4412 ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err));
4413 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
4414 }
4415
4416 /* TESTCASE: Tests that the HWC2 can get the max virtual display count. */
TEST_F(Hwc2Test,GET_MAX_VIRTUAL_DISPLAY_COUNT)4417 TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT)
4418 {
4419 uint32_t maxCnt;
4420
4421 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt));
4422 }
4423
4424 /* TESTCASE: Tests that the HWC2 returns the same max virtual display count for
4425 * each call. */
TEST_F(Hwc2Test,GET_MAX_VIRTUAL_DISPLAY_COUNT_duplicate)4426 TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_duplicate)
4427 {
4428 uint32_t maxCnt1, maxCnt2;
4429
4430 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt1));
4431 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt2));
4432
4433 EXPECT_EQ(maxCnt1, maxCnt2) << "returned two different max virtual display"
4434 " counts";
4435 }
4436
4437 /* TESTCASE: Tests that the HWC2 can create the max number of virtual displays
4438 * that it reports. */
TEST_F(Hwc2Test,GET_MAX_VIRTUAL_DISPLAY_COUNT_create_max)4439 TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_create_max)
4440 {
4441 std::vector<hwc2_display_t> displays;
4442 uint32_t maxCnt;
4443
4444 ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt));
4445
4446 while (displays.size() < maxCnt) {
4447 uint32_t width = 1920, height = 1080;
4448 android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888;
4449 hwc2_display_t display;
4450 hwc2_error_t err = HWC2_ERROR_NONE;
4451
4452 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(width, height,
4453 &desiredFormat, &display, &err));
4454
4455 EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED)
4456 << "returned wrong error code";
4457 if (err != HWC2_ERROR_NONE)
4458 break;
4459
4460 displays.push_back(display);
4461 }
4462
4463 for (hwc2_display_t display : displays) {
4464 EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display));
4465 }
4466 }
4467
4468 /* TESTCASE: Tests that the HWC2 can set an output buffer for a virtual
4469 * display. */
TEST_F(Hwc2Test,SET_OUTPUT_BUFFER)4470 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER)
4471 {
4472 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete,
4473 [] (Hwc2Test* test, hwc2_display_t display,
4474 Hwc2TestVirtualDisplay* testVirtualDisplay) {
4475
4476 buffer_handle_t handle;
4477 android::base::unique_fd acquireFence;
4478
4479 if (testVirtualDisplay->getBuffer(&handle, &acquireFence) >= 0)
4480 EXPECT_NO_FATAL_FAILURE(test->setOutputBuffer(display,
4481 handle, acquireFence));
4482 }));
4483 }
4484
4485 /* TESTCASE: Tests that the HWC2 cannot set an output buffer for a bad display */
TEST_F(Hwc2Test,SET_OUTPUT_BUFFER_bad_display)4486 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_display)
4487 {
4488 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default,
4489 [] (Hwc2Test* test, hwc2_display_t /*display*/,
4490 Hwc2TestVirtualDisplay* testVirtualDisplay) {
4491
4492 hwc2_display_t badDisplay;
4493 buffer_handle_t handle;
4494 android::base::unique_fd acquireFence;
4495 hwc2_error_t err = HWC2_ERROR_NONE;
4496
4497 ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay));
4498
4499 if (testVirtualDisplay->getBuffer(&handle, &acquireFence) < 0)
4500 return;
4501
4502 ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(badDisplay,
4503 handle, acquireFence, &err));
4504 EXPECT_TRUE(err == HWC2_ERROR_BAD_DISPLAY)
4505 << "returned wrong error code";
4506 }));
4507 }
4508
4509 /* TESTCASE: Tests that the HWC2 cannot set an invalid output buffer. */
TEST_F(Hwc2Test,SET_OUTPUT_BUFFER_bad_parameter)4510 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_parameter)
4511 {
4512 ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default,
4513 [] (Hwc2Test* test, hwc2_display_t display,
4514 Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) {
4515
4516 const buffer_handle_t handle = nullptr;
4517 uint32_t releaseFence = -1;
4518 hwc2_error_t err = HWC2_ERROR_NONE;
4519
4520 ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(display, handle,
4521 releaseFence, &err));
4522 EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER)
4523 << "returned wrong error code";
4524 }));
4525 }
4526
4527 /* TESTCASE: Tests that the HWC2 cannot set an output buffer for non virtual
4528 * display */
TEST_F(Hwc2Test,SET_OUTPUT_BUFFER_unsupported)4529 TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_unsupported)
4530 {
4531 for (auto display : mDisplays) {
4532 Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete);
4533
4534 do {
4535 buffer_handle_t handle;
4536 android::base::unique_fd acquireFence;
4537 hwc2_error_t err = HWC2_ERROR_NONE;
4538
4539 if (testVirtualDisplay.getBuffer(&handle, &acquireFence) < 0)
4540 continue;
4541
4542 ASSERT_NO_FATAL_FAILURE(setOutputBuffer(display, handle,
4543 acquireFence, &err));
4544 EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
4545
4546 } while (testVirtualDisplay.advance());
4547 }
4548 }
4549
4550 /* TESTCASE: Tests that the HWC2 can dump debug information. */
TEST_F(Hwc2Test,DUMP)4551 TEST_F(Hwc2Test, DUMP)
4552 {
4553 std::string buffer;
4554
4555 ASSERT_NO_FATAL_FAILURE(dump(&buffer));
4556 }
4557