Hwc2Test.cpp revision 600a73b6110d6fdcebe072a9d8e2dbbe6de1c6b7 
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 <gtest/gtest.h>
20#include <dlfcn.h>
21#include <hardware/hardware.h>
22
23#define HWC2_INCLUDE_STRINGIFICATION
24#define HWC2_USE_CPP11
25#include <hardware/hwcomposer2.h>
26#undef HWC2_INCLUDE_STRINGIFICATION
27#undef HWC2_USE_CPP11
28
29#include "Hwc2TestLayer.h"
30#include "Hwc2TestLayers.h"
31
32void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,
33        hwc2_display_t display, int32_t connected);
34void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,
35        hwc2_display_t display, int64_t timestamp);
36
37class Hwc2Test : public testing::Test {
38public:
39
40    virtual void SetUp()
41    {
42        hw_module_t const* hwc2Module;
43
44        int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &hwc2Module);
45        ASSERT_GE(err, 0) << "failed to get hwc hardware module: "
46                << strerror(-err);
47
48        /* The following method will fail if you have not run
49         * "adb shell stop" */
50        err = hwc2_open(hwc2Module, &mHwc2Device);
51        ASSERT_GE(err, 0) << "failed to open hwc hardware module: "
52                << strerror(-err);
53
54        populateDisplays();
55    }
56
57    virtual void TearDown()
58    {
59
60        for (auto itr = mLayers.begin(); itr != mLayers.end();) {
61            hwc2_display_t display = itr->first;
62            hwc2_layer_t layer = itr->second;
63            itr++;
64            /* Destroys and removes the layer from mLayers */
65            destroyLayer(display, layer);
66        }
67
68        for (auto itr = mActiveDisplays.begin(); itr != mActiveDisplays.end();) {
69            hwc2_display_t display = *itr;
70            itr++;
71            /* Sets power mode to off and removes the display from
72             * mActiveDisplays */
73            setPowerMode(display, HWC2_POWER_MODE_OFF);
74        }
75
76        if (mHwc2Device)
77            hwc2_close(mHwc2Device);
78    }
79
80    void registerCallback(hwc2_callback_descriptor_t descriptor,
81            hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer,
82            hwc2_error_t* outErr = nullptr)
83    {
84        auto pfn = reinterpret_cast<HWC2_PFN_REGISTER_CALLBACK>(
85                getFunction(HWC2_FUNCTION_REGISTER_CALLBACK));
86        ASSERT_TRUE(pfn) << "failed to get function";
87
88        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, descriptor,
89                callbackData, pointer));
90        if (outErr) {
91            *outErr = err;
92        } else {
93            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to register callback";
94        }
95    }
96
97    void getDisplayType(hwc2_display_t display, hwc2_display_type_t* outType,
98            hwc2_error_t* outErr = nullptr)
99    {
100        auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_TYPE>(
101                getFunction(HWC2_FUNCTION_GET_DISPLAY_TYPE));
102        ASSERT_TRUE(pfn) << "failed to get function";
103
104        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
105                    reinterpret_cast<int32_t*>(outType)));
106        if (outErr) {
107            *outErr = err;
108        } else {
109            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display type";
110        }
111    }
112
113    /* If the populateDisplays function is still receiving displays and the
114     * display is connected, the display handle is stored in mDisplays. */
115    void hotplugCallback(hwc2_display_t display, int32_t connected)
116    {
117        std::lock_guard<std::mutex> lock(mHotplugMutex);
118
119        if (mHotplugStatus != Hwc2TestHotplugStatus::Receiving)
120            return;
121
122        if (connected == HWC2_CONNECTION_CONNECTED)
123            mDisplays.insert(display);
124
125        mHotplugCv.notify_all();
126    }
127
128    void createLayer(hwc2_display_t display, hwc2_layer_t* outLayer,
129            hwc2_error_t* outErr = nullptr)
130    {
131        auto pfn = reinterpret_cast<HWC2_PFN_CREATE_LAYER>(
132                getFunction(HWC2_FUNCTION_CREATE_LAYER));
133        ASSERT_TRUE(pfn) << "failed to get function";
134
135        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
136                outLayer));
137
138        if (err == HWC2_ERROR_NONE)
139            mLayers.insert(std::make_pair(display, *outLayer));
140
141        if (outErr) {
142            *outErr = err;
143        } else {
144            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer";
145        }
146    }
147
148    void destroyLayer(hwc2_display_t display, hwc2_layer_t layer,
149            hwc2_error_t* outErr = nullptr)
150    {
151        auto pfn = reinterpret_cast<HWC2_PFN_DESTROY_LAYER>(
152                getFunction(HWC2_FUNCTION_DESTROY_LAYER));
153        ASSERT_TRUE(pfn) << "failed to get function";
154
155        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer));
156
157        if (err == HWC2_ERROR_NONE)
158            mLayers.erase(std::make_pair(display, layer));
159
160        if (outErr) {
161            *outErr = err;
162        } else {
163            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to destroy layer "
164                    << layer;
165        }
166    }
167
168    void getDisplayAttribute(hwc2_display_t display, hwc2_config_t config,
169            hwc2_attribute_t attribute, int32_t* outValue,
170            hwc2_error_t* outErr = nullptr)
171    {
172        auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
173                getFunction(HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE));
174        ASSERT_TRUE(pfn) << "failed to get function";
175
176        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config,
177                attribute, outValue));
178
179        if (outErr) {
180            *outErr = err;
181        } else {
182            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display attribute "
183                    << getAttributeName(attribute) << " for config " << config;
184        }
185    }
186
187    void getDisplayConfigs(hwc2_display_t display,
188            std::vector<hwc2_config_t>* outConfigs,
189            hwc2_error_t* outErr = nullptr)
190    {
191        auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_CONFIGS>(
192                getFunction(HWC2_FUNCTION_GET_DISPLAY_CONFIGS));
193        ASSERT_TRUE(pfn) << "failed to get function";
194
195        uint32_t numConfigs = 0;
196
197        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
198                &numConfigs, nullptr));
199
200        if (err == HWC2_ERROR_NONE) {
201            outConfigs->resize(numConfigs);
202
203            err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
204                    &numConfigs, outConfigs->data()));
205        }
206
207        if (outErr) {
208            *outErr = err;
209        } else {
210            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get configs for"
211                    " display " << display;
212        }
213    }
214
215    void getActiveConfig(hwc2_display_t display, hwc2_config_t* outConfig,
216            hwc2_error_t* outErr = nullptr)
217    {
218        auto pfn = reinterpret_cast<HWC2_PFN_GET_ACTIVE_CONFIG>(
219                getFunction(HWC2_FUNCTION_GET_ACTIVE_CONFIG));
220        ASSERT_TRUE(pfn) << "failed to get function";
221
222        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
223                outConfig));
224        if (outErr) {
225            *outErr = err;
226        } else {
227            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get active config on"
228                    " display " << display;
229        }
230    }
231
232    void setActiveConfig(hwc2_display_t display, hwc2_config_t config,
233            hwc2_error_t* outErr = nullptr)
234    {
235        auto pfn = reinterpret_cast<HWC2_PFN_SET_ACTIVE_CONFIG>(
236                getFunction(HWC2_FUNCTION_SET_ACTIVE_CONFIG));
237        ASSERT_TRUE(pfn) << "failed to get function";
238
239        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, config));
240        if (outErr) {
241            *outErr = err;
242        } else {
243            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set active config "
244                    << config;
245        }
246    }
247
248    void getDozeSupport(hwc2_display_t display, int32_t* outSupport,
249            hwc2_error_t* outErr = nullptr)
250    {
251        auto pfn = reinterpret_cast<HWC2_PFN_GET_DOZE_SUPPORT>(
252                getFunction(HWC2_FUNCTION_GET_DOZE_SUPPORT));
253        ASSERT_TRUE(pfn) << "failed to get function";
254
255        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
256                outSupport));
257        if (outErr) {
258            *outErr = err;
259        } else {
260            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get doze support on"
261                    " display " << display;
262        }
263    }
264
265    void setPowerMode(hwc2_display_t display, hwc2_power_mode_t mode,
266            hwc2_error_t* outErr = nullptr)
267    {
268        auto pfn = reinterpret_cast<HWC2_PFN_SET_POWER_MODE>(
269                getFunction(HWC2_FUNCTION_SET_POWER_MODE));
270        ASSERT_TRUE(pfn) << "failed to get function";
271
272        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
273                mode));
274        if (outErr) {
275            *outErr = err;
276            if (err != HWC2_ERROR_NONE)
277                return;
278        } else {
279            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set power mode "
280                    << getPowerModeName(mode) << " on display " << display;
281        }
282
283        if (mode == HWC2_POWER_MODE_OFF) {
284            mActiveDisplays.erase(display);
285        } else {
286            mActiveDisplays.insert(display);
287        }
288    }
289
290    void setVsyncEnabled(hwc2_display_t display, hwc2_vsync_t enabled,
291            hwc2_error_t* outErr = nullptr)
292    {
293        auto pfn = reinterpret_cast<HWC2_PFN_SET_VSYNC_ENABLED>(
294                getFunction(HWC2_FUNCTION_SET_VSYNC_ENABLED));
295        ASSERT_TRUE(pfn) << "failed to get function";
296
297        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
298                enabled));
299        if (outErr) {
300            *outErr = err;
301        } else {
302            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set vsync enabled "
303                    << getVsyncName(enabled);
304        }
305    }
306
307    void vsyncCallback(hwc2_display_t display, int64_t timestamp)
308    {
309        std::lock_guard<std::mutex> lock(mVsyncMutex);
310        mVsyncDisplay = display;
311        mVsyncTimestamp = timestamp;
312        mVsyncCv.notify_all();
313    }
314
315    void getDisplayName(hwc2_display_t display, std::string* outName,
316                hwc2_error_t* outErr = nullptr)
317    {
318        auto pfn = reinterpret_cast<HWC2_PFN_GET_DISPLAY_NAME>(
319                getFunction(HWC2_FUNCTION_GET_DISPLAY_NAME));
320        ASSERT_TRUE(pfn) << "failed to get function";
321
322        uint32_t size = 0;
323
324        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size,
325                nullptr));
326
327        if (err == HWC2_ERROR_NONE) {
328            std::vector<char> name(size);
329
330            err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, &size,
331                    name.data()));
332
333            outName->assign(name.data());
334        }
335
336        if (outErr) {
337            *outErr = err;
338        } else {
339            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to get display name for "
340                    << display;
341        }
342    }
343
344    void setLayerCompositionType(hwc2_display_t display, hwc2_layer_t layer,
345            hwc2_composition_t composition, hwc2_error_t* outErr = nullptr)
346    {
347        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
348                getFunction(HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE));
349        ASSERT_TRUE(pfn) << "failed to get function";
350
351        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
352                composition));
353        if (outErr) {
354            *outErr = err;
355        } else {
356            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer composition"
357                    " type " << getCompositionName(composition);
358        }
359    }
360
361    void setLayerBlendMode(hwc2_display_t display, hwc2_layer_t layer,
362            hwc2_blend_mode_t mode, hwc2_error_t* outErr = nullptr)
363    {
364        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BLEND_MODE>(
365                getFunction(HWC2_FUNCTION_SET_LAYER_BLEND_MODE));
366        ASSERT_TRUE(pfn) << "failed to get function";
367
368        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
369                mode));
370        if (outErr) {
371            *outErr = err;
372        } else {
373            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer blend mode "
374                    << getBlendModeName(mode);
375        }
376    }
377
378    void setLayerDataspace(hwc2_display_t display, hwc2_layer_t layer,
379            android_dataspace_t dataspace, hwc2_error_t* outErr = nullptr)
380    {
381        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DATASPACE>(
382                getFunction(HWC2_FUNCTION_SET_LAYER_DATASPACE));
383        ASSERT_TRUE(pfn) << "failed to get function";
384
385        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display,
386                layer, dataspace));
387        if (outErr) {
388            *outErr = err;
389        } else {
390            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer dataspace";
391        }
392    }
393
394    void setLayerDisplayFrame(hwc2_display_t display, hwc2_layer_t layer,
395            const hwc_rect_t& displayFrame, hwc2_error_t* outErr = nullptr)
396    {
397        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
398                getFunction(HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME));
399        ASSERT_TRUE(pfn) << "failed to get function";
400
401        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
402                displayFrame));
403        if (outErr) {
404            *outErr = err;
405        } else {
406            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer display"
407                    " frame";
408        }
409    }
410
411    void setLayerPlaneAlpha(hwc2_display_t display, hwc2_layer_t layer,
412            float alpha, hwc2_error_t* outErr = nullptr)
413    {
414        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
415                getFunction(HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA));
416        ASSERT_TRUE(pfn) << "failed to get function";
417
418        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
419                alpha));
420        if (outErr) {
421            *outErr = err;
422        } else {
423            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer plane alpha "
424                    << alpha;
425        }
426    }
427
428    void setLayerTransform(hwc2_display_t display, hwc2_layer_t layer,
429            hwc_transform_t transform, hwc2_error_t* outErr = nullptr)
430    {
431        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_TRANSFORM>(
432                getFunction(HWC2_FUNCTION_SET_LAYER_TRANSFORM));
433        ASSERT_TRUE(pfn) << "failed to get function";
434
435        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
436                transform));
437        if (outErr) {
438            *outErr = err;
439        } else {
440            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer transform "
441                    << getTransformName(transform);
442        }
443    }
444
445    void setLayerZOrder(hwc2_display_t display, hwc2_layer_t layer,
446            uint32_t zOrder, hwc2_error_t* outErr = nullptr)
447    {
448        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_Z_ORDER>(
449                getFunction(HWC2_FUNCTION_SET_LAYER_Z_ORDER));
450        ASSERT_TRUE(pfn) << "failed to get function";
451
452        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,
453                zOrder));
454        if (outErr) {
455            *outErr = err;
456        } else {
457            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer z order "
458                    << zOrder;
459        }
460    }
461
462protected:
463    hwc2_function_pointer_t getFunction(hwc2_function_descriptor_t descriptor)
464    {
465        return mHwc2Device->getFunction(mHwc2Device, descriptor);
466    }
467
468    void getCapabilities(std::vector<hwc2_capability_t>* outCapabilities)
469    {
470        uint32_t num = 0;
471
472        mHwc2Device->getCapabilities(mHwc2Device, &num, nullptr);
473
474        outCapabilities->resize(num);
475
476        mHwc2Device->getCapabilities(mHwc2Device, &num,
477                reinterpret_cast<int32_t*>(outCapabilities->data()));
478    }
479
480    /* Registers a hotplug callback and waits for hotplug callbacks. This
481     * function will have no effect if called more than once. */
482    void populateDisplays()
483    {
484        /* Sets the hotplug status to receiving */
485        {
486            std::lock_guard<std::mutex> lock(mHotplugMutex);
487
488            if (mHotplugStatus != Hwc2TestHotplugStatus::Init)
489                return;
490            mHotplugStatus = Hwc2TestHotplugStatus::Receiving;
491        }
492
493        /* Registers the callback. This function call cannot be locked because
494         * a callback could happen on the same thread */
495        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_HOTPLUG, this,
496                reinterpret_cast<hwc2_function_pointer_t>(
497                hwc2TestHotplugCallback)));
498
499        /* Waits for hotplug events. If a hotplug event has not come within 1
500         * second, stop waiting. */
501        std::unique_lock<std::mutex> lock(mHotplugMutex);
502
503        while (mHotplugCv.wait_for(lock, std::chrono::seconds(1)) !=
504                std::cv_status::timeout) { }
505
506        /* Sets the hotplug status to done. Future calls will have no effect */
507        mHotplugStatus = Hwc2TestHotplugStatus::Done;
508    }
509
510    void getBadDisplay(hwc2_display_t* outDisplay)
511    {
512        for (hwc2_display_t display = 0; display < UINT64_MAX; display++) {
513            if (mDisplays.count(display) == 0) {
514                *outDisplay = display;
515                return;
516            }
517        }
518        ASSERT_TRUE(false) << "Unable to find bad display. UINT64_MAX displays"
519                " are registered. This should never happen.";
520    }
521
522    /* NOTE: will create min(newlayerCnt, max supported layers) layers */
523    void createLayers(hwc2_display_t display,
524            std::vector<hwc2_layer_t>* outLayers, size_t newLayerCnt)
525    {
526        std::vector<hwc2_layer_t> newLayers;
527        hwc2_layer_t layer;
528        hwc2_error_t err = HWC2_ERROR_NONE;
529
530        for (size_t i = 0; i < newLayerCnt; i++) {
531
532            EXPECT_NO_FATAL_FAILURE(createLayer(display, &layer, &err));
533            if (err == HWC2_ERROR_NO_RESOURCES)
534                break;
535            if (err != HWC2_ERROR_NONE) {
536                newLayers.clear();
537                ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer";
538            }
539            newLayers.push_back(layer);
540        }
541
542        *outLayers = std::move(newLayers);
543    }
544
545    void destroyLayers(hwc2_display_t display,
546            std::vector<hwc2_layer_t>&& layers)
547    {
548        for (hwc2_layer_t layer : layers) {
549            EXPECT_NO_FATAL_FAILURE(destroyLayer(display, layer));
550        }
551    }
552
553    void getInvalidConfig(hwc2_display_t display, hwc2_config_t* outConfig)
554    {
555        std::vector<hwc2_config_t> configs;
556
557        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
558
559        hwc2_config_t CONFIG_MAX = UINT32_MAX;
560
561        ASSERT_LE(configs.size() - 1, CONFIG_MAX) << "every config value"
562                " (2^32 values) has been taken which shouldn't happen";
563
564        hwc2_config_t config;
565        for (config = 0; config < CONFIG_MAX; config++) {
566            if (std::count(configs.begin(), configs.end(), config) == 0)
567                break;
568        }
569
570        *outConfig = config;
571    }
572
573    void enableVsync(hwc2_display_t display)
574    {
575        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, this,
576                reinterpret_cast<hwc2_function_pointer_t>(
577                hwc2TestVsyncCallback)));
578        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
579    }
580
581    void disableVsync(hwc2_display_t display)
582    {
583        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
584    }
585
586    void waitForVsync(hwc2_display_t* outDisplay = nullptr,
587            int64_t* outTimestamp = nullptr)
588    {
589        std::unique_lock<std::mutex> lock(mVsyncMutex);
590        ASSERT_EQ(mVsyncCv.wait_for(lock, std::chrono::seconds(3)),
591                std::cv_status::no_timeout) << "timed out attempting to get"
592                " vsync callback";
593        if (outDisplay)
594            *outDisplay = mVsyncDisplay;
595        if (outTimestamp)
596            *outTimestamp = mVsyncTimestamp;
597    }
598
599    /* Calls a set property function from Hwc2Test to set a property value from
600     * Hwc2TestLayer to hwc2_layer_t on hwc2_display_t */
601    using TestLayerPropertyFunction = void (*)(Hwc2Test* test,
602            hwc2_display_t display, hwc2_layer_t layer,
603            const Hwc2TestLayer& testLayer, hwc2_error_t* outErr);
604
605    /* Calls a set property function from Hwc2Test to set property values from
606     * Hwc2TestLayers to hwc2_layer_t on hwc2_display_t */
607    using TestLayerPropertiesFunction = void (*)(Hwc2Test* test,
608            hwc2_display_t display, hwc2_layer_t layer,
609            const Hwc2TestLayers& testLayers);
610
611    /* Calls a set property function from Hwc2Test to set a bad property value
612     * on hwc2_layer_t on hwc2_display_t */
613    using TestLayerPropertyBadLayerFunction = void (*)(Hwc2Test* test,
614            hwc2_display_t display, hwc2_layer_t layer,
615            const Hwc2TestLayer& testLayer, hwc2_error_t* outErr);
616
617    /* Calls a set property function from Hwc2Test to set a bad property value
618     * on hwc2_layer_t on hwc2_display_t */
619    using TestLayerPropertyBadParameterFunction = void (*)(Hwc2Test* test,
620            hwc2_display_t display, hwc2_layer_t layer, hwc2_error_t* outErr);
621
622    /* Advances a property of Hwc2TestLayer */
623    using AdvanceProperty = bool (*)(Hwc2TestLayer* testLayer);
624
625    /* For each active display it cycles through each display config and tests
626     * each property value. It creates a layer, sets the property and then
627     * destroys the layer */
628    void setLayerProperty(Hwc2TestCoverage coverage,
629            TestLayerPropertyFunction function, AdvanceProperty advance)
630    {
631        for (auto display : mDisplays) {
632            std::vector<hwc2_config_t> configs;
633
634            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
635
636            for (auto config : configs) {
637                hwc2_layer_t layer;
638                Area displayArea;
639
640                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
641                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
642                        &displayArea));
643                Hwc2TestLayer testLayer(coverage, displayArea);
644
645                do {
646                    ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
647
648                    ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
649                            testLayer, nullptr));
650
651                    ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
652                } while (advance(&testLayer));
653            }
654        }
655    }
656
657    /* For each active display it cycles through each display config and tests
658     * each property value. It creates a layer, cycles through each property
659     * value and updates the layer property value and then destroys the layer */
660    void setLayerPropertyUpdate(Hwc2TestCoverage coverage,
661            TestLayerPropertyFunction function, AdvanceProperty advance)
662    {
663        for (auto display : mDisplays) {
664            std::vector<hwc2_config_t> configs;
665
666            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
667
668            for (auto config : configs) {
669                hwc2_layer_t layer;
670                Area displayArea;
671
672                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
673                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
674                        &displayArea));
675                Hwc2TestLayer testLayer(coverage, displayArea);
676
677                ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
678
679                do {
680                    ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
681                            testLayer, nullptr));
682                } while (advance(&testLayer));
683
684                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
685            }
686        }
687    }
688
689    /* For each active display it cycles through each display config and tests
690     * each property value. It creates multiple layers, calls the
691     * TestLayerPropertiesFunction to set property values and then
692     * destroys the layers */
693    void setLayerProperties(Hwc2TestCoverage coverage, size_t layerCnt,
694            TestLayerPropertiesFunction function)
695    {
696        for (auto display : mDisplays) {
697            std::vector<hwc2_config_t> configs;
698
699            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
700
701            for (auto config : configs) {
702                std::vector<hwc2_layer_t> layers;
703                Area displayArea;
704
705                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
706                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
707                        &displayArea));
708
709                ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
710                Hwc2TestLayers testLayers(layers, coverage, displayArea);
711
712                for (auto layer : layers) {
713                    EXPECT_NO_FATAL_FAILURE(function(this, display, layer,
714                            testLayers));
715                }
716
717                ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
718            }
719        }
720    }
721
722    /* For each active display it cycles through each display config.
723     * 1) It attempts to set a valid property value to bad layer handle.
724     * 2) It creates a layer x and attempts to set a valid property value to
725     *    layer x + 1
726     * 3) It destroys the layer x and attempts to set a valid property value to
727     *    the destroyed layer x.
728     */
729    void setLayerPropertyBadLayer(Hwc2TestCoverage coverage,
730            TestLayerPropertyBadLayerFunction function)
731    {
732        for (auto display : mDisplays) {
733            std::vector<hwc2_config_t> configs;
734
735            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
736
737            for (auto config : configs) {
738                hwc2_layer_t layer = 0;
739                Area displayArea;
740                hwc2_error_t err = HWC2_ERROR_NONE;
741
742                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
743                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
744                        &displayArea));
745                Hwc2TestLayer testLayer(coverage, displayArea);
746
747                ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
748                        testLayer, &err));
749                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
750
751                ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
752
753                ASSERT_NO_FATAL_FAILURE(function(this, display, layer + 1,
754                        testLayer, &err));
755                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
756
757                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
758
759                ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
760                        testLayer, &err));
761                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
762            }
763        }
764    }
765
766    /* For each active display it cycles through each display config and tests
767     * each property value. It creates a layer, sets a bad property value and
768     * then destroys the layer */
769    void setLayerPropertyBadParameter(TestLayerPropertyBadParameterFunction function)
770    {
771        for (auto display : mDisplays) {
772            std::vector<hwc2_config_t> configs;
773
774            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
775
776            for (auto config : configs) {
777                hwc2_layer_t layer;
778                hwc2_error_t err = HWC2_ERROR_NONE;
779
780                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
781
782                ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
783
784                ASSERT_NO_FATAL_FAILURE(function(this, display, layer, &err));
785                EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong"
786                        " error code";
787
788                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
789            }
790        }
791    }
792
793    void getActiveConfigAttribute(hwc2_display_t display,
794            hwc2_attribute_t attribute, int32_t* outValue)
795    {
796        hwc2_config_t config;
797        ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &config));
798        ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
799                attribute, outValue));
800        ASSERT_GE(*outValue, 0) << "failed to get valid "
801                << getAttributeName(attribute);
802    }
803
804    void getActiveDisplayArea(hwc2_display_t display, Area* displayArea)
805    {
806        ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display,
807                HWC2_ATTRIBUTE_WIDTH, &displayArea->width));
808        ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display,
809                HWC2_ATTRIBUTE_HEIGHT, &displayArea->height));
810    }
811
812    hwc2_device_t* mHwc2Device = nullptr;
813
814    enum class Hwc2TestHotplugStatus {
815        Init = 1,
816        Receiving,
817        Done,
818    };
819
820    std::mutex mHotplugMutex;
821    std::condition_variable mHotplugCv;
822    Hwc2TestHotplugStatus mHotplugStatus = Hwc2TestHotplugStatus::Init;
823    std::unordered_set<hwc2_display_t> mDisplays;
824
825    /* Store all created layers that have not been destroyed. If an ASSERT_*
826     * fails, then destroy the layers on exit */
827    std::set<std::pair<hwc2_display_t, hwc2_layer_t>> mLayers;
828
829    /* Store the power mode state. If it is not HWC2_POWER_MODE_OFF when
830     * tearing down the test cases, change it to HWC2_POWER_MODE_OFF */
831    std::set<hwc2_display_t> mActiveDisplays;
832
833    std::mutex mVsyncMutex;
834    std::condition_variable mVsyncCv;
835    hwc2_display_t mVsyncDisplay;
836    int64_t mVsyncTimestamp = -1;
837};
838
839void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,
840        hwc2_display_t display, int32_t connection)
841{
842    if (callbackData)
843        static_cast<Hwc2Test*>(callbackData)->hotplugCallback(display,
844                connection);
845}
846
847void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,
848        hwc2_display_t display, int64_t timestamp)
849{
850    if (callbackData)
851        static_cast<Hwc2Test*>(callbackData)->vsyncCallback(display,
852                timestamp);
853}
854
855void setBlendMode(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
856        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)
857{
858    EXPECT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,
859            testLayer.getBlendMode(), outErr));
860}
861
862void setComposition(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
863        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)
864{
865    hwc2_composition_t composition = testLayer.getComposition();
866    hwc2_error_t err = HWC2_ERROR_NONE;
867
868    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer,
869            composition, &err));
870    if (outErr) {
871        *outErr = err;
872        return;
873    }
874
875    if (composition != HWC2_COMPOSITION_SIDEBAND) {
876        EXPECT_EQ(err, HWC2_ERROR_NONE) << "returned wrong error code";
877    } else {
878        EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED)
879                 << "returned wrong error code";
880    }
881}
882
883void setDataspace(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
884        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)
885{
886    EXPECT_NO_FATAL_FAILURE(test->setLayerDataspace(display, layer,
887            testLayer.getDataspace(), outErr));
888}
889
890void setDisplayFrame(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
891        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)
892{
893    EXPECT_NO_FATAL_FAILURE(test->setLayerDisplayFrame(display, layer,
894            testLayer.getDisplayFrame(), outErr));
895}
896
897void setPlaneAlpha(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
898        const Hwc2TestLayer& testLayer, hwc2_error_t *outErr)
899{
900    ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,
901            testLayer.getBlendMode()));
902    EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, layer,
903            testLayer.getPlaneAlpha(), outErr));
904}
905
906void setTransform(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
907        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)
908{
909    EXPECT_NO_FATAL_FAILURE(test->setLayerTransform(display, layer,
910            testLayer.getTransform(), outErr));
911}
912
913void setZOrder(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
914        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)
915{
916    EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,
917            testLayer.getZOrder(), outErr));
918}
919
920bool advanceBlendMode(Hwc2TestLayer* testLayer)
921{
922    return testLayer->advanceBlendMode();
923}
924
925bool advanceComposition(Hwc2TestLayer* testLayer)
926{
927    return testLayer->advanceComposition();
928}
929
930bool advanceDataspace(Hwc2TestLayer* testLayer)
931{
932    return testLayer->advanceDataspace();
933}
934
935bool advanceDisplayFrame(Hwc2TestLayer* testLayer)
936{
937    return testLayer->advanceDisplayFrame();
938}
939
940bool advancePlaneAlpha(Hwc2TestLayer* testLayer)
941{
942    return testLayer->advancePlaneAlpha();
943}
944
945bool advanceTransform(Hwc2TestLayer* testLayer)
946{
947    return testLayer->advanceTransform();
948}
949
950
951static const std::array<hwc2_function_descriptor_t, 42> requiredFunctions = {{
952    HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES,
953    HWC2_FUNCTION_CREATE_LAYER,
954    HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY,
955    HWC2_FUNCTION_DESTROY_LAYER,
956    HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY,
957    HWC2_FUNCTION_DUMP,
958    HWC2_FUNCTION_GET_ACTIVE_CONFIG,
959    HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES,
960    HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT,
961    HWC2_FUNCTION_GET_COLOR_MODES,
962    HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE,
963    HWC2_FUNCTION_GET_DISPLAY_CONFIGS,
964    HWC2_FUNCTION_GET_DISPLAY_NAME,
965    HWC2_FUNCTION_GET_DISPLAY_REQUESTS,
966    HWC2_FUNCTION_GET_DISPLAY_TYPE,
967    HWC2_FUNCTION_GET_DOZE_SUPPORT,
968    HWC2_FUNCTION_GET_HDR_CAPABILITIES,
969    HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT,
970    HWC2_FUNCTION_GET_RELEASE_FENCES,
971    HWC2_FUNCTION_PRESENT_DISPLAY,
972    HWC2_FUNCTION_REGISTER_CALLBACK,
973    HWC2_FUNCTION_SET_ACTIVE_CONFIG,
974    HWC2_FUNCTION_SET_CLIENT_TARGET,
975    HWC2_FUNCTION_SET_COLOR_MODE,
976    HWC2_FUNCTION_SET_COLOR_TRANSFORM,
977    HWC2_FUNCTION_SET_CURSOR_POSITION,
978    HWC2_FUNCTION_SET_LAYER_BLEND_MODE,
979    HWC2_FUNCTION_SET_LAYER_BUFFER,
980    HWC2_FUNCTION_SET_LAYER_COLOR,
981    HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE,
982    HWC2_FUNCTION_SET_LAYER_DATASPACE,
983    HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME,
984    HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA,
985    HWC2_FUNCTION_SET_LAYER_SOURCE_CROP,
986    HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE,
987    HWC2_FUNCTION_SET_LAYER_TRANSFORM,
988    HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION,
989    HWC2_FUNCTION_SET_LAYER_Z_ORDER,
990    HWC2_FUNCTION_SET_OUTPUT_BUFFER,
991    HWC2_FUNCTION_SET_POWER_MODE,
992    HWC2_FUNCTION_SET_VSYNC_ENABLED,
993    HWC2_FUNCTION_VALIDATE_DISPLAY,
994}};
995
996/* TESTCASE: Tests that the HWC2 supports all required functions. */
997TEST_F(Hwc2Test, GET_FUNCTION)
998{
999    for (hwc2_function_descriptor_t descriptor : requiredFunctions) {
1000        hwc2_function_pointer_t pfn = getFunction(descriptor);
1001        EXPECT_TRUE(pfn) << "failed to get function "
1002                << getFunctionDescriptorName(descriptor);
1003    }
1004}
1005
1006/* TESTCASE: Tests that the HWC2 fails to retrieve and invalid function. */
1007TEST_F(Hwc2Test, GET_FUNCTION_invalid_function)
1008{
1009    hwc2_function_pointer_t pfn = getFunction(HWC2_FUNCTION_INVALID);
1010    EXPECT_FALSE(pfn) << "failed to get invalid function";
1011}
1012
1013/* TESTCASE: Tests that the HWC2 does not return an invalid capability. */
1014TEST_F(Hwc2Test, GET_CAPABILITIES)
1015{
1016    std::vector<hwc2_capability_t> capabilities;
1017
1018    getCapabilities(&capabilities);
1019
1020    EXPECT_EQ(std::count(capabilities.begin(), capabilities.end(),
1021            HWC2_CAPABILITY_INVALID), 0);
1022}
1023
1024static const std::array<hwc2_callback_descriptor_t, 3> callbackDescriptors = {{
1025    HWC2_CALLBACK_HOTPLUG,
1026    HWC2_CALLBACK_REFRESH,
1027    HWC2_CALLBACK_VSYNC,
1028}};
1029
1030/* TESTCASE: Tests that the HWC2 can successfully register all required
1031 * callback functions. */
1032TEST_F(Hwc2Test, REGISTER_CALLBACK)
1033{
1034    hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
1035            const_cast<char*>("data"));
1036
1037    for (auto descriptor : callbackDescriptors) {
1038        ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data,
1039                []() { return; }));
1040    }
1041}
1042
1043/* TESTCASE: Test that the HWC2 fails to register invalid callbacks. */
1044TEST_F(Hwc2Test, REGISTER_CALLBACK_bad_parameter)
1045{
1046    hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
1047            const_cast<char*>("data"));
1048    hwc2_error_t err = HWC2_ERROR_NONE;
1049
1050    ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_INVALID, data,
1051            []() { return; }, &err));
1052    EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
1053}
1054
1055/* TESTCASE: Tests that the HWC2 can register a callback with null data. */
1056TEST_F(Hwc2Test, REGISTER_CALLBACK_null_data)
1057{
1058    hwc2_callback_data_t data = nullptr;
1059
1060    for (auto descriptor : callbackDescriptors) {
1061        ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data,
1062                []() { return; }));
1063    }
1064}
1065
1066/* TESTCASE: Tests that the HWC2 returns the correct display type for each
1067 * physical display. */
1068TEST_F(Hwc2Test, GET_DISPLAY_TYPE)
1069{
1070    for (auto display : mDisplays) {
1071        hwc2_display_type_t type;
1072
1073        ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type));
1074        EXPECT_EQ(type, HWC2_DISPLAY_TYPE_PHYSICAL) << "failed to return"
1075                " correct display type";
1076    }
1077}
1078
1079/* TESTCASE: Tests that the HWC2 returns an error when the display type of a bad
1080 * display is requested. */
1081TEST_F(Hwc2Test, GET_DISPLAY_TYPE_bad_display)
1082{
1083    hwc2_display_t display;
1084    hwc2_display_type_t type;
1085    hwc2_error_t err = HWC2_ERROR_NONE;
1086
1087    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1088
1089    ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type, &err));
1090    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1091}
1092
1093/* TESTCASE: Tests that the HWC2 can create and destroy layers. */
1094TEST_F(Hwc2Test, CREATE_DESTROY_LAYER)
1095{
1096    for (auto display : mDisplays) {
1097        hwc2_layer_t layer;
1098
1099        ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1100
1101        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1102    }
1103}
1104
1105/* TESTCASE: Tests that the HWC2 cannot create a layer for a bad display */
1106TEST_F(Hwc2Test, CREATE_LAYER_bad_display)
1107{
1108    hwc2_display_t display;
1109    hwc2_layer_t layer;
1110    hwc2_error_t err = HWC2_ERROR_NONE;
1111
1112    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1113
1114    ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer, &err));
1115    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1116}
1117
1118/* TESTCASE: Tests that the HWC2 will either support a large number of resources
1119 * or will return no resources. */
1120TEST_F(Hwc2Test, CREATE_LAYER_no_resources)
1121{
1122    const size_t layerCnt = 1000;
1123
1124    for (auto display : mDisplays) {
1125        std::vector<hwc2_layer_t> layers;
1126
1127        ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1128
1129        ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
1130    }
1131}
1132
1133/* TESTCASE: Tests that the HWC2 cannot destroy a layer for a bad display */
1134TEST_F(Hwc2Test, DESTROY_LAYER_bad_display)
1135{
1136    hwc2_display_t badDisplay;
1137
1138    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&badDisplay));
1139
1140    for (auto display : mDisplays) {
1141        hwc2_layer_t layer = 0;
1142        hwc2_error_t err = HWC2_ERROR_NONE;
1143
1144        ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err));
1145        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1146
1147        ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1148
1149        ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err));
1150        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1151
1152        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1153    }
1154}
1155
1156/* TESTCASE: Tests that the HWC2 cannot destory a bad layer */
1157TEST_F(Hwc2Test, DESTROY_LAYER_bad_layer)
1158{
1159    for (auto display : mDisplays) {
1160        hwc2_layer_t layer;
1161        hwc2_error_t err = HWC2_ERROR_NONE;
1162
1163        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX / 2, &err));
1164        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1165
1166        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 0, &err));
1167        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1168
1169        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX - 1, &err));
1170        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1171
1172        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 1, &err));
1173        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1174
1175        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX, &err));
1176        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1177
1178        ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1179
1180        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer + 1, &err));
1181        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1182
1183        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1184
1185        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer, &err));
1186        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1187    }
1188}
1189
1190static const std::array<hwc2_attribute_t, 2> requiredAttributes = {{
1191    HWC2_ATTRIBUTE_WIDTH,
1192    HWC2_ATTRIBUTE_HEIGHT,
1193}};
1194
1195static const std::array<hwc2_attribute_t, 3> optionalAttributes = {{
1196    HWC2_ATTRIBUTE_VSYNC_PERIOD,
1197    HWC2_ATTRIBUTE_DPI_X,
1198    HWC2_ATTRIBUTE_DPI_Y,
1199}};
1200
1201/* TESTCASE: Tests that the HWC2 can return display attributes for a valid
1202 * config. */
1203TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE)
1204{
1205    for (auto display : mDisplays) {
1206        std::vector<hwc2_config_t> configs;
1207
1208        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1209
1210        for (auto config : configs) {
1211            int32_t value;
1212
1213            for (auto attribute : requiredAttributes) {
1214                ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
1215                        attribute, &value));
1216                EXPECT_GE(value, 0) << "missing required attribute "
1217                        << getAttributeName(attribute) << " for config "
1218                        << config;
1219            }
1220            for (auto attribute : optionalAttributes) {
1221                ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
1222                        attribute, &value));
1223            }
1224        }
1225    }
1226}
1227
1228/* TESTCASE: Tests that the HWC2 will return a value of -1 for an invalid
1229 * attribute */
1230TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_invalid_attribute)
1231{
1232    const hwc2_attribute_t attribute = HWC2_ATTRIBUTE_INVALID;
1233
1234    for (auto display : mDisplays) {
1235        std::vector<hwc2_config_t> configs;
1236
1237        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1238
1239        for (auto config : configs) {
1240            int32_t value;
1241            hwc2_error_t err = HWC2_ERROR_NONE;
1242
1243            ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
1244                    attribute, &value, &err));
1245            EXPECT_EQ(value, -1) << "failed to return -1 for an invalid"
1246                    " attribute for config " << config;
1247        }
1248    }
1249}
1250
1251/* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad display */
1252TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_display)
1253{
1254    hwc2_display_t display;
1255    const hwc2_config_t config = 0;
1256    int32_t value;
1257    hwc2_error_t err = HWC2_ERROR_NONE;
1258
1259    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1260
1261    for (auto attribute : requiredAttributes) {
1262        ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute,
1263                &value, &err));
1264        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1265    }
1266
1267    for (auto attribute : optionalAttributes) {
1268        ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute,
1269                &value, &err));
1270        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1271    }
1272}
1273
1274/* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad config */
1275TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_config)
1276{
1277    for (auto display : mDisplays) {
1278        hwc2_config_t config;
1279        int32_t value;
1280        hwc2_error_t err = HWC2_ERROR_NONE;
1281
1282        ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config));
1283
1284        for (auto attribute : requiredAttributes) {
1285            ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
1286                    attribute, &value, &err));
1287            EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
1288        }
1289
1290        for (auto attribute : optionalAttributes) {
1291            ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
1292                    attribute, &value, &err));
1293            EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
1294        }
1295    }
1296}
1297
1298/* TESTCASE: Tests that the HWC2 will get display configs for active displays */
1299TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS)
1300{
1301    for (auto display : mDisplays) {
1302        std::vector<hwc2_config_t> configs;
1303
1304        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1305    }
1306}
1307
1308/* TESTCASE: Tests that the HWC2 will not get display configs for bad displays */
1309TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_bad_display)
1310{
1311    hwc2_display_t display;
1312    std::vector<hwc2_config_t> configs;
1313    hwc2_error_t err = HWC2_ERROR_NONE;
1314
1315    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1316
1317    ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs, &err));
1318
1319    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1320    EXPECT_TRUE(configs.empty()) << "returned configs for bad display";
1321}
1322
1323/* TESTCASE: Tests that the HWC2 will return the same config list multiple
1324 * times in a row. */
1325TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_same)
1326{
1327    for (auto display : mDisplays) {
1328        std::vector<hwc2_config_t> configs1, configs2;
1329
1330        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs1));
1331        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs2));
1332
1333        EXPECT_TRUE(std::is_permutation(configs1.begin(), configs1.end(),
1334                configs2.begin())) << "returned two different config sets";
1335    }
1336}
1337
1338/* TESTCASE: Tests that the HWC2 does not return duplicate display configs */
1339TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_duplicate)
1340{
1341    for (auto display : mDisplays) {
1342        std::vector<hwc2_config_t> configs;
1343
1344        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1345
1346        std::unordered_set<hwc2_config_t> configsSet(configs.begin(),
1347                configs.end());
1348        EXPECT_EQ(configs.size(), configsSet.size()) << "returned duplicate"
1349                " configs";
1350    }
1351}
1352
1353/* TESTCASE: Tests that the HWC2 returns the active config for a display */
1354TEST_F(Hwc2Test, GET_ACTIVE_CONFIG)
1355{
1356    for (auto display : mDisplays) {
1357        std::vector<hwc2_config_t> configs;
1358
1359        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1360
1361        for (auto config : configs) {
1362            hwc2_config_t activeConfig;
1363
1364            ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1365            ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig));
1366
1367            EXPECT_EQ(activeConfig, config) << "failed to get active config";
1368        }
1369    }
1370}
1371
1372/* TESTCASE: Tests that the HWC2 does not return an active config for a bad
1373 * display. */
1374TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_display)
1375{
1376    hwc2_display_t display;
1377    hwc2_config_t activeConfig;
1378    hwc2_error_t err = HWC2_ERROR_NONE;
1379
1380    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1381
1382    ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err));
1383
1384    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1385}
1386
1387/* TESTCASE: Tests that the HWC2 either begins with a valid active config
1388 * or returns an error when getActiveConfig is called. */
1389TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_config)
1390{
1391    for (auto display : mDisplays) {
1392        std::vector<hwc2_config_t> configs;
1393        hwc2_config_t activeConfig;
1394        hwc2_error_t err = HWC2_ERROR_NONE;
1395
1396        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1397
1398        if (configs.empty())
1399            return;
1400
1401        ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err));
1402        if (err == HWC2_ERROR_NONE) {
1403            EXPECT_NE(std::count(configs.begin(), configs.end(),
1404                    activeConfig), 0) << "active config is not found in "
1405                    " configs for display";
1406        } else {
1407            EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
1408        }
1409    }
1410}
1411
1412/* TESTCASE: Tests that the HWC2 can set every display config as an active
1413 * config */
1414TEST_F(Hwc2Test, SET_ACTIVE_CONFIG)
1415{
1416    for (auto display : mDisplays) {
1417        std::vector<hwc2_config_t> configs;
1418
1419        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1420
1421        for (auto config : configs) {
1422            EXPECT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1423        }
1424    }
1425}
1426
1427/* TESTCASE: Tests that the HWC2 cannot set an active config for a bad display */
1428TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_display)
1429{
1430    hwc2_display_t display;
1431    const hwc2_config_t config = 0;
1432    hwc2_error_t err = HWC2_ERROR_NONE;
1433
1434    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1435
1436    ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err));
1437    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1438}
1439
1440/* TESTCASE: Tests that the HWC2 cannot set an invalid active config */
1441TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_config)
1442{
1443    for (auto display : mDisplays) {
1444        hwc2_config_t config;
1445        hwc2_error_t err = HWC2_ERROR_NONE;
1446
1447        ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config));
1448
1449        ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err));
1450        EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
1451    }
1452}
1453
1454/* TESTCASE: Tests that the HWC2 returns a valid value for getDozeSupport. */
1455TEST_F(Hwc2Test, GET_DOZE_SUPPORT)
1456{
1457    for (auto display : mDisplays) {
1458        int32_t support = -1;
1459
1460        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
1461
1462        EXPECT_TRUE(support == 0 || support == 1) << "invalid doze support value";
1463    }
1464}
1465
1466/* TESTCASE: Tests that the HWC2 cannot get doze support for a bad display. */
1467TEST_F(Hwc2Test, GET_DOZE_SUPPORT_bad_display)
1468{
1469    hwc2_display_t display;
1470    int32_t support = -1;
1471    hwc2_error_t err = HWC2_ERROR_NONE;
1472
1473    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1474
1475    ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
1476
1477    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1478}
1479
1480/* TESTCASE: Tests that the HWC2 can set all supported power modes */
1481TEST_F(Hwc2Test, SET_POWER_MODE)
1482{
1483    for (auto display : mDisplays) {
1484        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1485        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1486
1487        int32_t support = -1;
1488        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
1489        if (support != 1)
1490            return;
1491
1492        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
1493        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
1494                HWC2_POWER_MODE_DOZE_SUSPEND));
1495
1496        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1497    }
1498}
1499
1500/* TESTCASE: Tests that the HWC2 cannot set a power mode for a bad display. */
1501TEST_F(Hwc2Test, SET_POWER_MODE_bad_display)
1502{
1503    hwc2_display_t display;
1504    hwc2_error_t err = HWC2_ERROR_NONE;
1505
1506    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1507
1508    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON, &err));
1509    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1510
1511    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF, &err));
1512    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1513
1514    int32_t support = -1;
1515    ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
1516    if (support != 1)
1517        return;
1518
1519    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE, &err));
1520    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1521
1522    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE_SUSPEND,
1523            &err));
1524    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1525}
1526
1527/* TESTCASE: Tests that the HWC2 cannot set an invalid power mode value. */
1528TEST_F(Hwc2Test, SET_POWER_MODE_bad_parameter)
1529{
1530    for (auto display : mDisplays) {
1531        hwc2_power_mode_t mode = static_cast<hwc2_power_mode_t>(
1532                HWC2_POWER_MODE_DOZE_SUSPEND + 1);
1533        hwc2_error_t err = HWC2_ERROR_NONE;
1534
1535        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, mode, &err));
1536        EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code "
1537                << mode;
1538    }
1539}
1540
1541/* TESTCASE: Tests that the HWC2 will return unsupported if it does not support
1542 * an optional power mode. */
1543TEST_F(Hwc2Test, SET_POWER_MODE_unsupported)
1544{
1545    for (auto display : mDisplays) {
1546        int32_t support = -1;
1547        hwc2_error_t err = HWC2_ERROR_NONE;
1548
1549        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
1550        if (support == 1)
1551            return;
1552
1553        ASSERT_EQ(support, 0) << "invalid doze support value";
1554
1555        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE,
1556                &err));
1557        EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
1558
1559        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
1560                HWC2_POWER_MODE_DOZE_SUSPEND, &err));
1561        EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) <<  "returned wrong error code";
1562    }
1563}
1564
1565/* TESTCASE: Tests that the HWC2 can set the same power mode multiple times. */
1566TEST_F(Hwc2Test, SET_POWER_MODE_stress)
1567{
1568    for (auto display : mDisplays) {
1569        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1570        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1571
1572        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1573        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1574
1575        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1576        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1577
1578        int32_t support = -1;
1579        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
1580        if (support != 1)
1581            return;
1582
1583        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
1584        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
1585
1586        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
1587                HWC2_POWER_MODE_DOZE_SUSPEND));
1588        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
1589                HWC2_POWER_MODE_DOZE_SUSPEND));
1590
1591        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1592    }
1593}
1594
1595/* TESTCASE: Tests that the HWC2 can enable and disable vsync on active
1596 * displays */
1597TEST_F(Hwc2Test, SET_VSYNC_ENABLED)
1598{
1599    for (auto display : mDisplays) {
1600        hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
1601                const_cast<char*>("data"));
1602
1603        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1604
1605        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
1606                []() { return; }));
1607
1608        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
1609
1610        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1611
1612        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1613    }
1614}
1615
1616/* TESTCASE: Tests that the HWC2 issues a valid vsync callback. */
1617TEST_F(Hwc2Test, SET_VSYNC_ENABLED_callback)
1618{
1619    for (auto display : mDisplays) {
1620        hwc2_display_t receivedDisplay;
1621        int64_t receivedTimestamp;
1622
1623        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1624
1625        ASSERT_NO_FATAL_FAILURE(enableVsync(display));
1626
1627        ASSERT_NO_FATAL_FAILURE(waitForVsync(&receivedDisplay,
1628                &receivedTimestamp));
1629
1630        EXPECT_EQ(receivedDisplay, display) << "failed to get correct display";
1631        EXPECT_GE(receivedTimestamp, 0) << "failed to get valid timestamp";
1632
1633        ASSERT_NO_FATAL_FAILURE(disableVsync(display));
1634
1635        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1636    }
1637}
1638
1639/* TESTCASE: Tests that the HWC2 cannot enable a vsync for a bad display */
1640TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_display)
1641{
1642    hwc2_display_t display;
1643    hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
1644            const_cast<char*>("data"));
1645    hwc2_error_t err = HWC2_ERROR_NONE;
1646
1647    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1648
1649    ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
1650            []() { return; }));
1651
1652    ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE, &err));
1653    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1654
1655    ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE, &err));
1656    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1657}
1658
1659/* TESTCASE: Tests that the HWC2 cannot enable an invalid vsync value */
1660TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_parameter)
1661{
1662    for (auto display : mDisplays) {
1663        hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
1664                const_cast<char*>("data"));
1665        hwc2_error_t err = HWC2_ERROR_NONE;
1666
1667        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1668
1669        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
1670                []() { return; }));
1671
1672        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_INVALID,
1673                &err));
1674        EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
1675
1676        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1677    }
1678}
1679
1680/* TESTCASE: Tests that the HWC2 can enable and disable a vsync value multiple
1681 * times. */
1682TEST_F(Hwc2Test, SET_VSYNC_ENABLED_stress)
1683{
1684    for (auto display : mDisplays) {
1685        hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
1686                const_cast<char*>("data"));
1687
1688        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1689
1690        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
1691                []() { return; }));
1692
1693        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1694
1695        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
1696        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
1697
1698        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1699        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1700
1701        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1702    }
1703}
1704
1705/* TESTCASE: Tests that the HWC2 can set a vsync enable value when the display
1706 * is off and no callback is registered. */
1707TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback_no_power)
1708{
1709    const uint secs = 1;
1710
1711    for (auto display : mDisplays) {
1712        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
1713
1714        sleep(secs);
1715
1716        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1717    }
1718}
1719
1720/* TESTCASE: Tests that the HWC2 can set a vsync enable value when no callback
1721 * is registered. */
1722TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback)
1723{
1724    const uint secs = 1;
1725
1726    for (auto display : mDisplays) {
1727        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1728
1729        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
1730
1731        sleep(secs);
1732
1733        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1734
1735        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1736    }
1737}
1738
1739/* TESTCASE: Tests that the HWC2 returns a display name for each display */
1740TEST_F(Hwc2Test, GET_DISPLAY_NAME)
1741{
1742    for (auto display : mDisplays) {
1743        std::string name;
1744
1745        ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name));
1746    }
1747}
1748
1749/* TESTCASE: Tests that the HWC2 does not return a display name for a bad
1750 * display */
1751TEST_F(Hwc2Test, GET_DISPLAY_NAME_bad_display)
1752{
1753    hwc2_display_t display;
1754    std::string name;
1755    hwc2_error_t err = HWC2_ERROR_NONE;
1756
1757    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
1758
1759    ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name, &err));
1760    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
1761}
1762
1763/* TESTCASE: Tests that the HWC2 can set basic composition types. */
1764TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE)
1765{
1766    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
1767            setComposition, advanceComposition));
1768}
1769
1770/* TESTCASE: Tests that the HWC2 can update a basic composition type on a
1771 * layer. */
1772TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_update)
1773{
1774    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
1775            setComposition, advanceComposition));
1776}
1777
1778/* TESTCASE: Tests that the HWC2 cannot set a composition type for a bad layer */
1779TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_layer)
1780{
1781    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
1782            setComposition));
1783}
1784
1785/* TESTCASE: Tests that the HWC2 cannot set a bad composition type */
1786TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_parameter)
1787{
1788    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
1789            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1790                    hwc2_error_t* outErr) {
1791
1792                ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,
1793                        layer, HWC2_COMPOSITION_INVALID, outErr));
1794            }
1795    ));
1796}
1797
1798/* TESTCASE: Tests that the HWC2 can set a blend mode value of a layer. */
1799TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE)
1800{
1801    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
1802            setBlendMode, advanceBlendMode));
1803}
1804
1805/* TESTCASE: Tests that the HWC2 can update a blend mode value of a layer. */
1806TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_update)
1807{
1808    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
1809            setBlendMode, advanceBlendMode));
1810}
1811
1812/* TESTCASE: Tests that the HWC2 cannot set a blend mode for a bad layer. */
1813TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_layer)
1814{
1815    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
1816            setBlendMode));
1817}
1818
1819/* TESTCASE: Tests that the HWC2 cannot set an invalid blend mode. */
1820TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_parameter)
1821{
1822    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
1823            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1824                    hwc2_error_t* outErr) {
1825
1826                ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display,
1827                        layer, HWC2_BLEND_MODE_INVALID, outErr));
1828            }
1829    ));
1830}
1831
1832/* TESTCASE: Tests that the HWC2 can set the dataspace of a layer. */
1833TEST_F(Hwc2Test, SET_LAYER_DATASPACE)
1834{
1835    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
1836            setDataspace, advanceDataspace));
1837}
1838
1839/* TESTCASE: Tests that the HWC2 can update the dataspace of a layer. */
1840TEST_F(Hwc2Test, SET_LAYER_DATASPACE_update)
1841{
1842    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
1843            setDataspace, advanceDataspace));
1844}
1845
1846/* TESTCASE: Tests that the HWC2 cannot set a dataspace for a bad layer. */
1847TEST_F(Hwc2Test, SET_LAYER_DATASPACE_bad_layer)
1848{
1849    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
1850            setDataspace));
1851}
1852
1853/* TESTCASE: Tests that the HWC2 can set the display frame of a layer. */
1854TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME)
1855{
1856    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
1857            setDisplayFrame, advanceDisplayFrame));
1858}
1859
1860/* TESTCASE: Tests that the HWC2 can update the display frame of a layer. */
1861TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_update)
1862{
1863    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
1864            setDisplayFrame, advanceDisplayFrame));
1865}
1866
1867/* TESTCASE: Tests that the HWC2 cannot set the display frame of a bad layer. */
1868TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_bad_layer)
1869{
1870    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
1871            setDisplayFrame));
1872}
1873
1874/* TESTCASE: Tests that the HWC2 can set the plane alpha of a layer. */
1875TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA)
1876{
1877    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
1878            setPlaneAlpha, advancePlaneAlpha));
1879}
1880
1881/* TESTCASE: Tests that the HWC2 can update the plane alpha of a layer. */
1882TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_update)
1883{
1884    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
1885            setPlaneAlpha, advancePlaneAlpha));
1886}
1887
1888/* TESTCASE: Tests that the HWC2 cannot set a plane alpha for a bad layer. */
1889TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_bad_layer)
1890{
1891    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
1892            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
1893                    const Hwc2TestLayer& testLayer, hwc2_error_t *outErr) {
1894
1895                    EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,
1896                            badLayer, testLayer.getPlaneAlpha(), outErr));
1897            }
1898    ));
1899}
1900
1901/* TESTCASE: Tests that the HWC2 can set the transform value of a layer. */
1902TEST_F(Hwc2Test, SET_LAYER_TRANSFORM)
1903{
1904    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
1905            setTransform, advanceTransform));
1906}
1907
1908/* TESTCASE: Tests that the HWC2 can update the transform value of a layer. */
1909TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_update)
1910{
1911    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
1912            setTransform, advanceTransform));
1913}
1914
1915/* TESTCASE: Tests that the HWC2 cannot set the transform for a bad layer. */
1916TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_bad_layer)
1917{
1918    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
1919            setTransform));
1920}
1921
1922/* TESTCASE: Tests that the HWC2 can set the z order of a layer. */
1923TEST_F(Hwc2Test, SET_LAYER_Z_ORDER)
1924{
1925    ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Complete, 10,
1926            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1927                    const Hwc2TestLayers& testLayers) {
1928
1929                EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,
1930                        testLayers.getZOrder(layer)));
1931            }
1932    ));
1933}
1934
1935/* TESTCASE: Tests that the HWC2 can update the z order of a layer. */
1936TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_update)
1937{
1938    const std::vector<uint32_t> zOrders = { static_cast<uint32_t>(0),
1939            static_cast<uint32_t>(1), static_cast<uint32_t>(UINT32_MAX / 4),
1940            static_cast<uint32_t>(UINT32_MAX / 2),
1941            static_cast<uint32_t>(UINT32_MAX) };
1942
1943    for (auto display : mDisplays) {
1944        std::vector<hwc2_config_t> configs;
1945
1946        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1947
1948        for (auto config : configs) {
1949            hwc2_layer_t layer;
1950
1951            ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1952
1953            ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1954
1955            for (uint32_t zOrder : zOrders) {
1956                EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer, zOrder));
1957            }
1958
1959            ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1960        }
1961    }
1962}
1963
1964/* TESTCASE: Tests that the HWC2 cannot set the z order of a bad layer. */
1965TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_bad_layer)
1966{
1967    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
1968            setZOrder));
1969}
1970