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
37void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,
38        hwc2_display_t display, int32_t connected);
39void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,
40        hwc2_display_t display, int64_t timestamp);
41
42class Hwc2Test : public testing::Test {
43public:
44
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
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
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
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. */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1075    void disableVsync(hwc2_display_t display)
1076    {
1077        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1078    }
1079
1080protected:
1081    hwc2_function_pointer_t getFunction(hwc2_function_descriptor_t descriptor)
1082    {
1083        return mHwc2Device->getFunction(mHwc2Device, descriptor);
1084    }
1085
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. */
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 */
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
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
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 */
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 */
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 */
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     */
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 */
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 */
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 */
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 */
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 */
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 */
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
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
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
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
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
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
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
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
1805void 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
1813void 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
1821void 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
1828void 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
1849void 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
1862void 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
1883void 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
1894void 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
1901void 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
1908void 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
1917void 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
1924void 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
1931void 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
1938void 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
1945void 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
1952bool advanceBlendMode(Hwc2TestLayer* testLayer)
1953{
1954    return testLayer->advanceBlendMode();
1955}
1956
1957bool advanceBuffer(Hwc2TestLayer* testLayer)
1958{
1959    if (testLayer->advanceComposition())
1960        return true;
1961    return testLayer->advanceBufferArea();
1962}
1963
1964bool 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
1975bool advanceComposition(Hwc2TestLayer* testLayer)
1976{
1977    return testLayer->advanceComposition();
1978}
1979
1980bool advanceCursorPosition(Hwc2TestLayer* testLayer)
1981{
1982    return testLayer->advanceCursorPosition();
1983}
1984
1985bool advanceDataspace(Hwc2TestLayer* testLayer)
1986{
1987    return testLayer->advanceDataspace();
1988}
1989
1990bool advanceDisplayFrame(Hwc2TestLayer* testLayer)
1991{
1992    return testLayer->advanceDisplayFrame();
1993}
1994
1995bool advancePlaneAlpha(Hwc2TestLayer* testLayer)
1996{
1997    return testLayer->advancePlaneAlpha();
1998}
1999
2000bool advanceSourceCrop(Hwc2TestLayer* testLayer)
2001{
2002    if (testLayer->advanceSourceCrop())
2003        return true;
2004    return testLayer->advanceBufferArea();
2005}
2006
2007bool advanceSurfaceDamage(Hwc2TestLayer* testLayer)
2008{
2009    if (testLayer->advanceSurfaceDamage())
2010        return true;
2011    return testLayer->advanceBufferArea();
2012}
2013
2014bool advanceTransform(Hwc2TestLayer* testLayer)
2015{
2016    return testLayer->advanceTransform();
2017}
2018
2019bool advanceVisibleRegions(Hwc2TestLayers* testLayers)
2020{
2021    return testLayers->advanceVisibleRegions();
2022}
2023
2024bool advanceClientTargetSupport(
2025        Hwc2TestClientTargetSupport* testClientTargetSupport)
2026{
2027    return testClientTargetSupport->advance();
2028}
2029
2030static 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. */
2076TEST_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. */
2086TEST_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. */
2093TEST_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
2103static 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. */
2111TEST_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. */
2123TEST_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. */
2135TEST_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. */
2147TEST_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. */
2160TEST_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. */
2173TEST_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 */
2185TEST_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. */
2199TEST_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 */
2213TEST_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 */
2236TEST_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
2269static const std::array<hwc2_attribute_t, 2> requiredAttributes = {{
2270    HWC2_ATTRIBUTE_WIDTH,
2271    HWC2_ATTRIBUTE_HEIGHT,
2272}};
2273
2274static 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. */
2282TEST_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 */
2309TEST_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 */
2331TEST_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 */
2354TEST_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 */
2378TEST_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 */
2388TEST_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. */
2404TEST_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 */
2418TEST_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 */
2433TEST_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. */
2453TEST_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. */
2468TEST_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 */
2493TEST_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 */
2507TEST_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 */
2520TEST_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. */
2534TEST_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. */
2546TEST_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 */
2560TEST_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. */
2580TEST_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. */
2607TEST_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. */
2622TEST_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. */
2645TEST_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 */
2676TEST_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. */
2696TEST_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 */
2719TEST_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 */
2739TEST_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. */
2761TEST_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. */
2786TEST_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. */
2801TEST_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 */
2819TEST_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 */
2830TEST_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. */
2843TEST_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. */
2851TEST_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 */
2858TEST_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 */
2865TEST_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. */
2878TEST_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. */
2885TEST_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. */
2893TEST_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. */
2909TEST_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. */
2923TEST_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. */
2938TEST_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. */
2945TEST_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. */
2952TEST_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. */
2959TEST_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. */
2972TEST_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. */
2979TEST_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. */
2986TEST_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. */
3009TEST_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. */
3025TEST_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. */
3032TEST_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. */
3040TEST_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. */
3054TEST_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. */
3067TEST_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. */
3074TEST_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. */
3081TEST_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. */
3088TEST_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. */
3095TEST_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. */
3102TEST_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. */
3109TEST_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. */
3116TEST_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. */
3123TEST_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. */
3136TEST_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. */
3143TEST_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. */
3150TEST_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. */
3157TEST_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. */
3164TEST_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. */
3171TEST_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. */
3178TEST_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. */
3185TEST_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. */
3192TEST_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. */
3199TEST_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. */
3213TEST_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. */
3220TEST_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. */
3240TEST_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. */
3269TEST_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 */
3277TEST_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. */
3297TEST_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 */
3317TEST_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. */
3332TEST_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 */
3355TEST_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. */
3372TEST_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. */
3392TEST_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 */
3416TEST_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. */
3432TEST_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. */
3451TEST_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 */
3477TEST_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. */
3490TEST_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 */
3506TEST_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. */
3525TEST_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. */
3549TEST_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. */
3572TEST_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. */
3644TEST_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. */
3677TEST_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. */
3689TEST_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. */
3701TEST_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. */
3713TEST_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. */
3725TEST_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. */
3737TEST_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. */
3750TEST_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. */
3766TEST_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. */
3781TEST_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. */
3795TEST_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. */
3810TEST_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. */
3827TEST_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. */
3841TEST_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. */
3856TEST_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. */
3872TEST_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. */
3886TEST_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. */
3900TEST_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. */
3914TEST_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. */
3928TEST_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. */
3942TEST_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. */
3957TEST_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. */
3972TEST_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. */
3987TEST_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. */
4003TEST_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. */
4017TEST_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. */
4031TEST_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. */
4046TEST_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.  */
4058TEST_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. */
4071TEST_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. */
4100TEST_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
4113static 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 */
4127TEST_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. */
4145TEST_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. */
4158TEST_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. */
4171TEST_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. */
4184TEST_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. */
4203TEST_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. */
4224TEST_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 */
4246TEST_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
4260static 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
4270static 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 */
4295TEST_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. */
4308TEST_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. */
4321TEST_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. */
4339TEST_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. */
4356TEST_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. */
4365TEST_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.  */
4395TEST_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. */
4407TEST_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. */
4417TEST_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. */
4426TEST_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. */
4439TEST_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. */
4470TEST_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 */
4486TEST_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. */
4510TEST_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 */
4529TEST_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. */
4551TEST_F(Hwc2Test, DUMP)
4552{
4553    std::string buffer;
4554
4555    ASSERT_NO_FATAL_FAILURE(dump(&buffer));
4556}
4557