Hwc2Test.cpp revision bad1bc78ef50648fadbe725a1fe1c28d62097351 
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 getBadDisplay(hwc2_display_t* outDisplay)
1026    {
1027        for (hwc2_display_t display = 0; display < UINT64_MAX; display++) {
1028            if (mDisplays.count(display) == 0) {
1029                *outDisplay = display;
1030                return;
1031            }
1032        }
1033        ASSERT_TRUE(false) << "Unable to find bad display. UINT64_MAX displays"
1034                " are registered. This should never happen.";
1035    }
1036
1037    void waitForVsync(hwc2_display_t* outDisplay = nullptr,
1038            int64_t* outTimestamp = nullptr)
1039    {
1040        std::unique_lock<std::mutex> lock(mVsyncMutex);
1041        ASSERT_EQ(mVsyncCv.wait_for(lock, std::chrono::seconds(3)),
1042                std::cv_status::no_timeout) << "timed out attempting to get"
1043                " vsync callback";
1044        if (outDisplay)
1045            *outDisplay = mVsyncDisplay;
1046        if (outTimestamp)
1047            *outTimestamp = mVsyncTimestamp;
1048    }
1049
1050    void enableVsync(hwc2_display_t display)
1051    {
1052        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, this,
1053                reinterpret_cast<hwc2_function_pointer_t>(
1054                hwc2TestVsyncCallback)));
1055        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
1056    }
1057
1058    void disableVsync(hwc2_display_t display)
1059    {
1060        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
1061    }
1062
1063protected:
1064    hwc2_function_pointer_t getFunction(hwc2_function_descriptor_t descriptor)
1065    {
1066        return mHwc2Device->getFunction(mHwc2Device, descriptor);
1067    }
1068
1069    void getCapabilities(std::vector<hwc2_capability_t>* outCapabilities)
1070    {
1071        uint32_t num = 0;
1072
1073        mHwc2Device->getCapabilities(mHwc2Device, &num, nullptr);
1074
1075        outCapabilities->resize(num);
1076
1077        mHwc2Device->getCapabilities(mHwc2Device, &num,
1078                reinterpret_cast<int32_t*>(outCapabilities->data()));
1079    }
1080
1081    /* Registers a hotplug callback and waits for hotplug callbacks. This
1082     * function will have no effect if called more than once. */
1083    void populateDisplays()
1084    {
1085        /* Sets the hotplug status to receiving */
1086        {
1087            std::lock_guard<std::mutex> lock(mHotplugMutex);
1088
1089            if (mHotplugStatus != Hwc2TestHotplugStatus::Init)
1090                return;
1091            mHotplugStatus = Hwc2TestHotplugStatus::Receiving;
1092        }
1093
1094        /* Registers the callback. This function call cannot be locked because
1095         * a callback could happen on the same thread */
1096        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_HOTPLUG, this,
1097                reinterpret_cast<hwc2_function_pointer_t>(
1098                hwc2TestHotplugCallback)));
1099
1100        /* Waits for hotplug events. If a hotplug event has not come within 1
1101         * second, stop waiting. */
1102        std::unique_lock<std::mutex> lock(mHotplugMutex);
1103
1104        while (mHotplugCv.wait_for(lock, std::chrono::seconds(1)) !=
1105                std::cv_status::timeout) { }
1106
1107        /* Sets the hotplug status to done. Future calls will have no effect */
1108        mHotplugStatus = Hwc2TestHotplugStatus::Done;
1109    }
1110
1111    /* NOTE: will create min(newlayerCnt, max supported layers) layers */
1112    void createLayers(hwc2_display_t display,
1113            std::vector<hwc2_layer_t>* outLayers, size_t newLayerCnt)
1114    {
1115        std::vector<hwc2_layer_t> newLayers;
1116        hwc2_layer_t layer;
1117        hwc2_error_t err = HWC2_ERROR_NONE;
1118
1119        for (size_t i = 0; i < newLayerCnt; i++) {
1120
1121            EXPECT_NO_FATAL_FAILURE(createLayer(display, &layer, &err));
1122            if (err == HWC2_ERROR_NO_RESOURCES)
1123                break;
1124            if (err != HWC2_ERROR_NONE) {
1125                newLayers.clear();
1126                ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to create layer";
1127            }
1128            newLayers.push_back(layer);
1129        }
1130
1131        *outLayers = std::move(newLayers);
1132    }
1133
1134    void destroyLayers(hwc2_display_t display,
1135            std::vector<hwc2_layer_t>&& layers)
1136    {
1137        for (hwc2_layer_t layer : layers) {
1138            EXPECT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1139        }
1140    }
1141
1142    void getInvalidConfig(hwc2_display_t display, hwc2_config_t* outConfig)
1143    {
1144        std::vector<hwc2_config_t> configs;
1145
1146        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1147
1148        hwc2_config_t CONFIG_MAX = UINT32_MAX;
1149
1150        ASSERT_LE(configs.size() - 1, CONFIG_MAX) << "every config value"
1151                " (2^32 values) has been taken which shouldn't happen";
1152
1153        hwc2_config_t config;
1154        for (config = 0; config < CONFIG_MAX; config++) {
1155            if (std::count(configs.begin(), configs.end(), config) == 0)
1156                break;
1157        }
1158
1159        *outConfig = config;
1160    }
1161
1162    /* Calls a set property function from Hwc2Test to set a property value from
1163     * Hwc2TestLayer to hwc2_layer_t on hwc2_display_t */
1164    using TestLayerPropertyFunction = void (*)(Hwc2Test* test,
1165            hwc2_display_t display, hwc2_layer_t layer,
1166            Hwc2TestLayer* testLayer, hwc2_error_t* outErr);
1167
1168    /* Calls a set property function from Hwc2Test to set property values from
1169     * Hwc2TestLayers to hwc2_layer_t on hwc2_display_t */
1170    using TestLayerPropertiesFunction = void (*)(Hwc2Test* test,
1171            hwc2_display_t display, hwc2_layer_t layer,
1172            Hwc2TestLayers* testLayers);
1173
1174    /* Calls a set property function from Hwc2Test to set a bad property value
1175     * on hwc2_layer_t on hwc2_display_t */
1176    using TestLayerPropertyBadLayerFunction = void (*)(Hwc2Test* test,
1177            hwc2_display_t display, hwc2_layer_t layer,
1178            Hwc2TestLayer* testLayer, hwc2_error_t* outErr);
1179
1180    /* Calls a set property function from Hwc2Test to set a bad property value
1181     * on hwc2_layer_t on hwc2_display_t */
1182    using TestLayerPropertyBadParameterFunction = void (*)(Hwc2Test* test,
1183            hwc2_display_t display, hwc2_layer_t layer, hwc2_error_t* outErr);
1184
1185    /* Is called after a display is powered on and all layer properties have
1186     * been set. It should be used to test functions such as validate, accepting
1187     * changes, present, etc. */
1188    using TestDisplayLayersFunction = void (*)(Hwc2Test* test,
1189            hwc2_display_t display, const std::vector<hwc2_layer_t>& layers,
1190            Hwc2TestLayers* testLayers);
1191
1192    /* It is called on an non validated display */
1193    using TestDisplayNonValidatedLayersFunction = void (*)(Hwc2Test* test,
1194            hwc2_display_t display, std::vector<hwc2_layer_t>* layers);
1195
1196    /* Tests client target support on a particular display and config */
1197    using TestClientTargetSupportFunction = void (*)(Hwc2Test* test,
1198            hwc2_display_t display,
1199            const Hwc2TestClientTargetSupport& testClientTargetSupport);
1200
1201    /* Tests a particular active display config */
1202    using TestActiveDisplayConfigFunction = void (*)(Hwc2Test* test,
1203            hwc2_display_t display);
1204
1205    /* Tests a newly created virtual display */
1206    using TestCreateVirtualDisplayFunction = void (*)(Hwc2Test* test,
1207            hwc2_display_t display, Hwc2TestVirtualDisplay* testVirtualDisplay);
1208
1209    /* Advances a property of Hwc2TestLayer */
1210    using AdvanceProperty = bool (*)(Hwc2TestLayer* testLayer);
1211
1212    /* Advances properties of Hwc2TestLayers */
1213    using AdvanceProperties = bool (*)(Hwc2TestLayers* testLayer);
1214
1215    /* Advances properties of Hwc2TestClientTargetSupport */
1216    using AdvanceClientTargetSupport = bool (*)(
1217            Hwc2TestClientTargetSupport* testClientTargetSupport);
1218
1219    /* For each active display it cycles through each display config and tests
1220     * each property value. It creates a layer, sets the property and then
1221     * destroys the layer */
1222    void setLayerProperty(Hwc2TestCoverage coverage,
1223            TestLayerPropertyFunction function, AdvanceProperty advance)
1224    {
1225        for (auto display : mDisplays) {
1226            std::vector<hwc2_config_t> configs;
1227
1228            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1229
1230            for (auto config : configs) {
1231                hwc2_layer_t layer;
1232                Area displayArea;
1233
1234                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1235                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1236                        &displayArea));
1237                Hwc2TestLayer testLayer(coverage, displayArea);
1238
1239                do {
1240                    ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1241
1242                    ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1243                            &testLayer, nullptr));
1244
1245                    ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1246                } while (advance(&testLayer));
1247            }
1248        }
1249    }
1250
1251    /* For each active display it cycles through each display config and tests
1252     * each property value. It creates a layer, cycles through each property
1253     * value and updates the layer property value and then destroys the layer */
1254    void setLayerPropertyUpdate(Hwc2TestCoverage coverage,
1255            TestLayerPropertyFunction function, AdvanceProperty advance)
1256    {
1257        for (auto display : mDisplays) {
1258            std::vector<hwc2_config_t> configs;
1259
1260            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1261
1262            for (auto config : configs) {
1263                hwc2_layer_t layer;
1264                Area displayArea;
1265
1266                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1267                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1268                        &displayArea));
1269                Hwc2TestLayer testLayer(coverage, displayArea);
1270
1271                ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1272
1273                do {
1274                    ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1275                            &testLayer, nullptr));
1276                } while (advance(&testLayer));
1277
1278                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1279            }
1280        }
1281    }
1282
1283    /* For each active display it cycles through each display config and tests
1284     * each property value. It creates multiple layers, calls the
1285     * TestLayerPropertiesFunction to set property values and then
1286     * destroys the layers */
1287    void setLayerProperties(Hwc2TestCoverage coverage, size_t layerCnt,
1288            TestLayerPropertiesFunction function, AdvanceProperties advance)
1289    {
1290        for (auto display : mDisplays) {
1291            std::vector<hwc2_config_t> configs;
1292
1293            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1294
1295            for (auto config : configs) {
1296                std::vector<hwc2_layer_t> layers;
1297                Area displayArea;
1298
1299                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1300                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1301                        &displayArea));
1302
1303                ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1304                Hwc2TestLayers testLayers(layers, coverage, displayArea);
1305
1306                do {
1307                    for (auto layer : layers) {
1308                        EXPECT_NO_FATAL_FAILURE(function(this, display, layer,
1309                                &testLayers));
1310                    }
1311                } while (advance(&testLayers));
1312
1313                ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
1314            }
1315        }
1316    }
1317
1318    /* For each active display it cycles through each display config.
1319     * 1) It attempts to set a valid property value to bad layer handle.
1320     * 2) It creates a layer x and attempts to set a valid property value to
1321     *    layer x + 1
1322     * 3) It destroys the layer x and attempts to set a valid property value to
1323     *    the destroyed layer x.
1324     */
1325    void setLayerPropertyBadLayer(Hwc2TestCoverage coverage,
1326            TestLayerPropertyBadLayerFunction function)
1327    {
1328        for (auto display : mDisplays) {
1329            std::vector<hwc2_config_t> configs;
1330
1331            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1332
1333            for (auto config : configs) {
1334                hwc2_layer_t layer = 0;
1335                Area displayArea;
1336                hwc2_error_t err = HWC2_ERROR_NONE;
1337
1338                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1339                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1340                        &displayArea));
1341                Hwc2TestLayer testLayer(coverage, displayArea);
1342
1343                ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1344                        &testLayer, &err));
1345                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1346
1347                ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1348
1349                ASSERT_NO_FATAL_FAILURE(function(this, display, layer + 1,
1350                        &testLayer, &err));
1351                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1352
1353                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1354
1355                ASSERT_NO_FATAL_FAILURE(function(this, display, layer,
1356                        &testLayer, &err));
1357                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
1358            }
1359        }
1360    }
1361
1362    /* For each active display it cycles through each display config and tests
1363     * each property value. It creates a layer, sets a bad property value and
1364     * then destroys the layer */
1365    void setLayerPropertyBadParameter(TestLayerPropertyBadParameterFunction function)
1366    {
1367        for (auto display : mDisplays) {
1368            std::vector<hwc2_config_t> configs;
1369
1370            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1371
1372            for (auto config : configs) {
1373                hwc2_layer_t layer;
1374                hwc2_error_t err = HWC2_ERROR_NONE;
1375
1376                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1377
1378                ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
1379
1380                ASSERT_NO_FATAL_FAILURE(function(this, display, layer, &err));
1381                EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong"
1382                        " error code";
1383
1384                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
1385            }
1386        }
1387    }
1388
1389    /* For each active display it powers on the display, cycles through each
1390     * config and creates a set of layers with a certain amount of coverage.
1391     * For each active display, for each config and for each set of layers,
1392     * it calls the TestDisplayLayersFunction */
1393    void displayLayers(Hwc2TestCoverage coverage, size_t layerCnt,
1394            TestDisplayLayersFunction function)
1395    {
1396        for (auto display : mDisplays) {
1397            std::vector<hwc2_config_t> configs;
1398
1399            ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1400
1401            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1402
1403            for (auto config : configs) {
1404                Area displayArea;
1405                std::vector<hwc2_layer_t> layers;
1406
1407                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1408                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea));
1409
1410                ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1411                Hwc2TestLayers testLayers(layers, coverage, displayArea);
1412
1413                do {
1414                    bool skip;
1415
1416                    ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers,
1417                            &testLayers, &skip));
1418                    if (!skip)
1419                        EXPECT_NO_FATAL_FAILURE(function(this, display, layers,
1420                                &testLayers));
1421
1422                } while (testLayers.advance());
1423
1424                ASSERT_NO_FATAL_FAILURE(destroyLayers(display,
1425                        std::move(layers)));
1426            }
1427
1428            ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1429        }
1430    }
1431
1432    /* For each active display, it calls the
1433     * TestDisplayNonValidatedLayersFunction on a variety on non-validated
1434     * layer combinations */
1435    void displayNonValidatedLayers(size_t layerCnt,
1436            TestDisplayNonValidatedLayersFunction function)
1437    {
1438        for (auto display : mDisplays) {
1439            uint32_t numTypes, numRequests;
1440            std::vector<hwc2_layer_t> layers;
1441            bool hasChanges;
1442
1443            ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1444
1445            EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1446
1447            ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1448
1449            EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1450
1451            for (auto layer : layers) {
1452                ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer,
1453                        HWC2_COMPOSITION_CLIENT));
1454            }
1455
1456            EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1457
1458            ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes,
1459                    &numRequests, &hasChanges));
1460
1461            for (auto layer : layers) {
1462                ASSERT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer,
1463                        HWC2_COMPOSITION_DEVICE));
1464            }
1465
1466            EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1467
1468            ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
1469
1470            EXPECT_NO_FATAL_FAILURE(function(this, display, &layers));
1471
1472            ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1473        }
1474    }
1475
1476    /* Test client target support on each config on each active display */
1477    void setClientTargetSupport(Hwc2TestCoverage coverage,
1478            TestClientTargetSupportFunction function,
1479            AdvanceClientTargetSupport advance)
1480    {
1481        for (auto display : mDisplays) {
1482            std::vector<hwc2_config_t> configs;
1483
1484            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1485
1486            for (auto config : configs) {
1487                Area displayArea;
1488
1489                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1490                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1491                        &displayArea));
1492                Hwc2TestClientTargetSupport testClientTargetSupport(coverage,
1493                        displayArea);
1494
1495                do {
1496                    EXPECT_NO_FATAL_FAILURE(function(this, display,
1497                            testClientTargetSupport));
1498
1499                } while (advance(&testClientTargetSupport));
1500            }
1501        }
1502    }
1503
1504    /* Cycles through each config on each active display and calls
1505     * a TestActiveDisplayConfigFunction */
1506    void setActiveDisplayConfig(TestActiveDisplayConfigFunction function)
1507    {
1508        for (auto display : mDisplays) {
1509            std::vector<hwc2_config_t> configs;
1510
1511            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1512
1513            for (auto config : configs) {
1514                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1515
1516                EXPECT_NO_FATAL_FAILURE(function(this, display));
1517            }
1518        }
1519    }
1520
1521    /* Creates a virtual display for testing */
1522    void createVirtualDisplay(Hwc2TestCoverage coverage,
1523            TestCreateVirtualDisplayFunction function)
1524    {
1525        Hwc2TestVirtualDisplay testVirtualDisplay(coverage);
1526
1527        do {
1528            hwc2_display_t display;
1529            hwc2_error_t err = HWC2_ERROR_NONE;
1530
1531            const UnsignedArea& dimension =
1532                    testVirtualDisplay.getDisplayDimension();
1533            android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888;
1534
1535            ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width,
1536                    dimension.height, &desiredFormat, &display, &err));
1537
1538            EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES
1539                    || err == HWC2_ERROR_UNSUPPORTED)
1540                    << "returned wrong error code";
1541            EXPECT_GE(desiredFormat, 0) << "invalid format";
1542
1543            if (err != HWC2_ERROR_NONE)
1544                continue;
1545
1546            EXPECT_NO_FATAL_FAILURE(function(this, display,
1547                    &testVirtualDisplay));
1548
1549            ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display));
1550
1551        } while (testVirtualDisplay.advance());
1552    }
1553
1554
1555    void getActiveConfigAttribute(hwc2_display_t display,
1556            hwc2_attribute_t attribute, int32_t* outValue)
1557    {
1558        hwc2_config_t config;
1559        ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &config));
1560        ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
1561                attribute, outValue));
1562        ASSERT_GE(*outValue, 0) << "failed to get valid "
1563                << getAttributeName(attribute);
1564    }
1565
1566    void getActiveDisplayArea(hwc2_display_t display, Area* displayArea)
1567    {
1568        ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display,
1569                HWC2_ATTRIBUTE_WIDTH, &displayArea->width));
1570        ASSERT_NO_FATAL_FAILURE(getActiveConfigAttribute(display,
1571                HWC2_ATTRIBUTE_HEIGHT, &displayArea->height));
1572    }
1573
1574    void closeFences(hwc2_display_t display, int32_t presentFence)
1575    {
1576        std::vector<hwc2_layer_t> layers;
1577        std::vector<int32_t> fences;
1578        const int msWait = 3000;
1579
1580        if (presentFence >= 0) {
1581            ASSERT_GE(sync_wait(presentFence, msWait), 0);
1582            close(presentFence);
1583        }
1584
1585        ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences));
1586        EXPECT_EQ(layers.size(), fences.size());
1587
1588        for (int32_t fence : fences) {
1589            EXPECT_GE(sync_wait(fence, msWait), 0);
1590            if (fence >= 0)
1591                close(fence);
1592        }
1593    }
1594
1595    void setLayerProperties(hwc2_display_t display, hwc2_layer_t layer,
1596            Hwc2TestLayers* testLayers, bool* outSkip)
1597    {
1598        hwc2_composition_t composition;
1599        buffer_handle_t handle = nullptr;
1600        int32_t acquireFence;
1601        hwc2_error_t err = HWC2_ERROR_NONE;
1602        *outSkip = true;
1603
1604        if (!testLayers->contains(layer))
1605            return;
1606
1607        composition = testLayers->getComposition(layer);
1608
1609        /* If the device cannot support a buffer format, then do not continue */
1610        if ((composition == HWC2_COMPOSITION_DEVICE
1611                || composition == HWC2_COMPOSITION_CURSOR)
1612                && testLayers->getBuffer(layer, &handle, &acquireFence) < 0)
1613            return;
1614
1615        EXPECT_NO_FATAL_FAILURE(setLayerCompositionType(display, layer,
1616                composition, &err));
1617        if (err == HWC2_ERROR_UNSUPPORTED)
1618            EXPECT_TRUE(composition != HWC2_COMPOSITION_CLIENT
1619                    && composition != HWC2_COMPOSITION_DEVICE);
1620
1621        const hwc_rect_t cursor = testLayers->getCursorPosition(layer);
1622
1623        EXPECT_NO_FATAL_FAILURE(setLayerBuffer(display, layer, handle,
1624                acquireFence));
1625        EXPECT_NO_FATAL_FAILURE(setLayerBlendMode(display, layer,
1626                testLayers->getBlendMode(layer)));
1627        EXPECT_NO_FATAL_FAILURE(setLayerColor(display, layer,
1628                testLayers->getColor(layer)));
1629        EXPECT_NO_FATAL_FAILURE(setCursorPosition(display, layer, cursor.left,
1630                cursor.top));
1631        EXPECT_NO_FATAL_FAILURE(setLayerDataspace(display, layer,
1632                testLayers->getDataspace(layer)));
1633        EXPECT_NO_FATAL_FAILURE(setLayerDisplayFrame(display, layer,
1634                testLayers->getDisplayFrame(layer)));
1635        EXPECT_NO_FATAL_FAILURE(setLayerPlaneAlpha(display, layer,
1636                testLayers->getPlaneAlpha(layer)));
1637        EXPECT_NO_FATAL_FAILURE(setLayerSourceCrop(display, layer,
1638                testLayers->getSourceCrop(layer)));
1639        EXPECT_NO_FATAL_FAILURE(setLayerSurfaceDamage(display, layer,
1640                testLayers->getSurfaceDamage(layer)));
1641        EXPECT_NO_FATAL_FAILURE(setLayerTransform(display, layer,
1642                testLayers->getTransform(layer)));
1643        EXPECT_NO_FATAL_FAILURE(setLayerVisibleRegion(display, layer,
1644                testLayers->getVisibleRegion(layer)));
1645        EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer,
1646                testLayers->getZOrder(layer)));
1647
1648        *outSkip = false;
1649    }
1650
1651    void setLayerProperties(hwc2_display_t display,
1652            const std::vector<hwc2_layer_t>& layers,
1653            Hwc2TestLayers* testLayers, bool* outSkip)
1654    {
1655        for (auto layer : layers) {
1656            EXPECT_NO_FATAL_FAILURE(setLayerProperties(display, layer,
1657                    testLayers, outSkip));
1658            if (*outSkip)
1659                return;
1660        }
1661    }
1662
1663    void setClientTarget(hwc2_display_t display,
1664            Hwc2TestClientTarget* testClientTarget,
1665            const Hwc2TestLayers& testLayers,
1666            const std::set<hwc2_layer_t>& clientLayers,
1667            const std::set<hwc2_layer_t>& clearLayers, bool flipClientTarget,
1668            const Area& displayArea)
1669    {
1670        android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN;
1671        hwc_region_t damage = { };
1672        buffer_handle_t handle;
1673        int32_t acquireFence;
1674
1675        ASSERT_EQ(testClientTarget->getBuffer(testLayers, clientLayers,
1676                clearLayers, flipClientTarget, displayArea, &handle,
1677                &acquireFence), 0);
1678        EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence,
1679                dataspace, damage));
1680    }
1681
1682    void presentDisplays(size_t layerCnt, Hwc2TestCoverage coverage,
1683            const std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage>&
1684            coverageExceptions, bool optimize)
1685    {
1686        for (auto display : mDisplays) {
1687            std::vector<hwc2_config_t> configs;
1688
1689            ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
1690            ASSERT_NO_FATAL_FAILURE(enableVsync(display));
1691
1692            ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
1693
1694            for (auto config : configs) {
1695                Area displayArea;
1696                std::vector<hwc2_layer_t> layers;
1697
1698                ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
1699                ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display,
1700                        &displayArea));
1701
1702                ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
1703                Hwc2TestLayers testLayers(layers, coverage, displayArea,
1704                        coverageExceptions);
1705
1706                if (optimize && !testLayers.optimizeLayouts())
1707                    continue;
1708
1709                std::set<hwc2_layer_t> clientLayers;
1710                std::set<hwc2_layer_t> clearLayers;
1711                Hwc2TestClientTarget testClientTarget;
1712
1713                do {
1714                    uint32_t numTypes, numRequests;
1715                    bool hasChanges, skip;
1716                    bool flipClientTarget;
1717                    int32_t presentFence;
1718
1719                    ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers,
1720                            &testLayers, &skip));
1721                    if (skip)
1722                        continue;
1723
1724                    ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes,
1725                            &numRequests, &hasChanges));
1726                    if (hasChanges)
1727                        EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size()))
1728                                << "wrong number of requests";
1729
1730                    ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display,
1731                            testLayers, layers, numTypes, &clientLayers));
1732                    ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers,
1733                            numRequests, &clearLayers, &flipClientTarget));
1734                    ASSERT_NO_FATAL_FAILURE(setClientTarget(display,
1735                            &testClientTarget, testLayers, clientLayers,
1736                            clearLayers, flipClientTarget, displayArea));
1737                    ASSERT_NO_FATAL_FAILURE(acceptDisplayChanges(display));
1738
1739                    ASSERT_NO_FATAL_FAILURE(waitForVsync());
1740
1741                    EXPECT_NO_FATAL_FAILURE(presentDisplay(display,
1742                            &presentFence));
1743
1744                    ASSERT_NO_FATAL_FAILURE(closeFences(display, presentFence));
1745
1746                } while (testLayers.advance());
1747
1748                ASSERT_NO_FATAL_FAILURE(destroyLayers(display,
1749                        std::move(layers)));
1750            }
1751
1752            ASSERT_NO_FATAL_FAILURE(disableVsync(display));
1753            ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
1754        }
1755    }
1756
1757    hwc2_device_t* mHwc2Device = nullptr;
1758
1759    enum class Hwc2TestHotplugStatus {
1760        Init = 1,
1761        Receiving,
1762        Done,
1763    };
1764
1765    std::mutex mHotplugMutex;
1766    std::condition_variable mHotplugCv;
1767    Hwc2TestHotplugStatus mHotplugStatus = Hwc2TestHotplugStatus::Init;
1768    std::unordered_set<hwc2_display_t> mDisplays;
1769
1770    /* Store all created layers that have not been destroyed. If an ASSERT_*
1771     * fails, then destroy the layers on exit */
1772    std::set<std::pair<hwc2_display_t, hwc2_layer_t>> mLayers;
1773
1774    /* Store the power mode state. If it is not HWC2_POWER_MODE_OFF when
1775     * tearing down the test cases, change it to HWC2_POWER_MODE_OFF */
1776    std::set<hwc2_display_t> mActiveDisplays;
1777
1778    /* Store all created virtual displays that have not been destroyed. If an
1779     * ASSERT_* fails, then destroy the virtual displays on exit */
1780    std::set<hwc2_display_t> mVirtualDisplays;
1781
1782    std::mutex mVsyncMutex;
1783    std::condition_variable mVsyncCv;
1784    hwc2_display_t mVsyncDisplay;
1785    int64_t mVsyncTimestamp = -1;
1786};
1787
1788void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,
1789        hwc2_display_t display, int32_t connection)
1790{
1791    if (callbackData)
1792        static_cast<Hwc2Test*>(callbackData)->hotplugCallback(display,
1793                connection);
1794}
1795
1796void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,
1797        hwc2_display_t display, int64_t timestamp)
1798{
1799    if (callbackData)
1800        static_cast<Hwc2Test*>(callbackData)->vsyncCallback(display,
1801                timestamp);
1802}
1803
1804void setBlendMode(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1805        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1806{
1807    EXPECT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,
1808            testLayer->getBlendMode(), outErr));
1809}
1810
1811void setBuffer(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1812        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1813{
1814    buffer_handle_t handle;
1815    android::base::unique_fd acquireFence;
1816    hwc2_composition_t composition = testLayer->getComposition();
1817
1818    if (composition == HWC2_COMPOSITION_CLIENT
1819            || composition == HWC2_COMPOSITION_SOLID_COLOR
1820            || composition == HWC2_COMPOSITION_SIDEBAND)
1821        return;
1822
1823    if (testLayer->getBuffer(&handle, &acquireFence) < 0)
1824        return;
1825
1826    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer,
1827            composition));
1828    EXPECT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer,
1829            handle, acquireFence, outErr));
1830}
1831
1832void setColor(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1833        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1834{
1835    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,
1836            layer, HWC2_COMPOSITION_SOLID_COLOR));
1837    ASSERT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,
1838            layer, testLayer->getPlaneAlpha()));
1839    ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display,
1840            layer, testLayer->getBlendMode()));
1841    EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,
1842            testLayer->getColor(), outErr));
1843}
1844
1845void setComposition(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1846        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1847{
1848    hwc2_composition_t composition = testLayer->getComposition();
1849    hwc2_error_t err = HWC2_ERROR_NONE;
1850
1851    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer,
1852            composition, &err));
1853    if (outErr) {
1854        *outErr = err;
1855        return;
1856    }
1857
1858    if (composition != HWC2_COMPOSITION_SIDEBAND) {
1859        EXPECT_EQ(err, HWC2_ERROR_NONE) << "returned wrong error code";
1860    } else {
1861        EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED)
1862                 << "returned wrong error code";
1863    }
1864}
1865
1866void setCursorPosition(Hwc2Test* test, hwc2_display_t display,
1867        hwc2_layer_t layer, Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1868{
1869    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,
1870            layer, HWC2_COMPOSITION_CURSOR));
1871
1872    const hwc_rect_t cursorPosition = testLayer->getCursorPosition();
1873    EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer,
1874            cursorPosition.left, cursorPosition.top, outErr));
1875}
1876
1877void setDataspace(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1878        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1879{
1880    EXPECT_NO_FATAL_FAILURE(test->setLayerDataspace(display, layer,
1881            testLayer->getDataspace(), outErr));
1882}
1883
1884void setDisplayFrame(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1885        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1886{
1887    EXPECT_NO_FATAL_FAILURE(test->setLayerDisplayFrame(display, layer,
1888            testLayer->getDisplayFrame(), outErr));
1889}
1890
1891void setPlaneAlpha(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1892        Hwc2TestLayer* testLayer, hwc2_error_t *outErr)
1893{
1894    ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,
1895            testLayer->getBlendMode()));
1896    EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, layer,
1897            testLayer->getPlaneAlpha(), outErr));
1898}
1899
1900void setSourceCrop(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1901        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1902{
1903    EXPECT_NO_FATAL_FAILURE(test->setLayerSourceCrop(display, layer,
1904            testLayer->getSourceCrop(), outErr));
1905}
1906
1907void setSurfaceDamage(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1908        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1909{
1910    EXPECT_NO_FATAL_FAILURE(test->setLayerSurfaceDamage(display, layer,
1911            testLayer->getSurfaceDamage(), outErr));
1912}
1913
1914void setTransform(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1915        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1916{
1917    EXPECT_NO_FATAL_FAILURE(test->setLayerTransform(display, layer,
1918            testLayer->getTransform(), outErr));
1919}
1920
1921void setVisibleRegion(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1922        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1923{
1924    EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display, layer,
1925            testLayer->getVisibleRegion(), outErr));
1926}
1927
1928void setZOrder(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
1929        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)
1930{
1931    EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,
1932            testLayer->getZOrder(), outErr));
1933}
1934
1935bool advanceBlendMode(Hwc2TestLayer* testLayer)
1936{
1937    return testLayer->advanceBlendMode();
1938}
1939
1940bool advanceBuffer(Hwc2TestLayer* testLayer)
1941{
1942    if (testLayer->advanceComposition())
1943        return true;
1944    return testLayer->advanceBufferArea();
1945}
1946
1947bool advanceColor(Hwc2TestLayer* testLayer)
1948{
1949    /* Color depends on blend mode so advance blend mode last so color is not
1950     * force to update as often */
1951    if (testLayer->advancePlaneAlpha())
1952        return true;
1953    if (testLayer->advanceColor())
1954        return true;
1955    return testLayer->advanceBlendMode();
1956}
1957
1958bool advanceComposition(Hwc2TestLayer* testLayer)
1959{
1960    return testLayer->advanceComposition();
1961}
1962
1963bool advanceCursorPosition(Hwc2TestLayer* testLayer)
1964{
1965    return testLayer->advanceCursorPosition();
1966}
1967
1968bool advanceDataspace(Hwc2TestLayer* testLayer)
1969{
1970    return testLayer->advanceDataspace();
1971}
1972
1973bool advanceDisplayFrame(Hwc2TestLayer* testLayer)
1974{
1975    return testLayer->advanceDisplayFrame();
1976}
1977
1978bool advancePlaneAlpha(Hwc2TestLayer* testLayer)
1979{
1980    return testLayer->advancePlaneAlpha();
1981}
1982
1983bool advanceSourceCrop(Hwc2TestLayer* testLayer)
1984{
1985    if (testLayer->advanceSourceCrop())
1986        return true;
1987    return testLayer->advanceBufferArea();
1988}
1989
1990bool advanceSurfaceDamage(Hwc2TestLayer* testLayer)
1991{
1992    if (testLayer->advanceSurfaceDamage())
1993        return true;
1994    return testLayer->advanceBufferArea();
1995}
1996
1997bool advanceTransform(Hwc2TestLayer* testLayer)
1998{
1999    return testLayer->advanceTransform();
2000}
2001
2002bool advanceVisibleRegions(Hwc2TestLayers* testLayers)
2003{
2004    return testLayers->advanceVisibleRegions();
2005}
2006
2007bool advanceClientTargetSupport(
2008        Hwc2TestClientTargetSupport* testClientTargetSupport)
2009{
2010    return testClientTargetSupport->advance();
2011}
2012
2013static const std::array<hwc2_function_descriptor_t, 42> requiredFunctions = {{
2014    HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES,
2015    HWC2_FUNCTION_CREATE_LAYER,
2016    HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY,
2017    HWC2_FUNCTION_DESTROY_LAYER,
2018    HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY,
2019    HWC2_FUNCTION_DUMP,
2020    HWC2_FUNCTION_GET_ACTIVE_CONFIG,
2021    HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES,
2022    HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT,
2023    HWC2_FUNCTION_GET_COLOR_MODES,
2024    HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE,
2025    HWC2_FUNCTION_GET_DISPLAY_CONFIGS,
2026    HWC2_FUNCTION_GET_DISPLAY_NAME,
2027    HWC2_FUNCTION_GET_DISPLAY_REQUESTS,
2028    HWC2_FUNCTION_GET_DISPLAY_TYPE,
2029    HWC2_FUNCTION_GET_DOZE_SUPPORT,
2030    HWC2_FUNCTION_GET_HDR_CAPABILITIES,
2031    HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT,
2032    HWC2_FUNCTION_GET_RELEASE_FENCES,
2033    HWC2_FUNCTION_PRESENT_DISPLAY,
2034    HWC2_FUNCTION_REGISTER_CALLBACK,
2035    HWC2_FUNCTION_SET_ACTIVE_CONFIG,
2036    HWC2_FUNCTION_SET_CLIENT_TARGET,
2037    HWC2_FUNCTION_SET_COLOR_MODE,
2038    HWC2_FUNCTION_SET_COLOR_TRANSFORM,
2039    HWC2_FUNCTION_SET_CURSOR_POSITION,
2040    HWC2_FUNCTION_SET_LAYER_BLEND_MODE,
2041    HWC2_FUNCTION_SET_LAYER_BUFFER,
2042    HWC2_FUNCTION_SET_LAYER_COLOR,
2043    HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE,
2044    HWC2_FUNCTION_SET_LAYER_DATASPACE,
2045    HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME,
2046    HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA,
2047    HWC2_FUNCTION_SET_LAYER_SOURCE_CROP,
2048    HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE,
2049    HWC2_FUNCTION_SET_LAYER_TRANSFORM,
2050    HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION,
2051    HWC2_FUNCTION_SET_LAYER_Z_ORDER,
2052    HWC2_FUNCTION_SET_OUTPUT_BUFFER,
2053    HWC2_FUNCTION_SET_POWER_MODE,
2054    HWC2_FUNCTION_SET_VSYNC_ENABLED,
2055    HWC2_FUNCTION_VALIDATE_DISPLAY,
2056}};
2057
2058/* TESTCASE: Tests that the HWC2 supports all required functions. */
2059TEST_F(Hwc2Test, GET_FUNCTION)
2060{
2061    for (hwc2_function_descriptor_t descriptor : requiredFunctions) {
2062        hwc2_function_pointer_t pfn = getFunction(descriptor);
2063        EXPECT_TRUE(pfn) << "failed to get function "
2064                << getFunctionDescriptorName(descriptor);
2065    }
2066}
2067
2068/* TESTCASE: Tests that the HWC2 fails to retrieve and invalid function. */
2069TEST_F(Hwc2Test, GET_FUNCTION_invalid_function)
2070{
2071    hwc2_function_pointer_t pfn = getFunction(HWC2_FUNCTION_INVALID);
2072    EXPECT_FALSE(pfn) << "failed to get invalid function";
2073}
2074
2075/* TESTCASE: Tests that the HWC2 does not return an invalid capability. */
2076TEST_F(Hwc2Test, GET_CAPABILITIES)
2077{
2078    std::vector<hwc2_capability_t> capabilities;
2079
2080    getCapabilities(&capabilities);
2081
2082    EXPECT_EQ(std::count(capabilities.begin(), capabilities.end(),
2083            HWC2_CAPABILITY_INVALID), 0);
2084}
2085
2086static const std::array<hwc2_callback_descriptor_t, 3> callbackDescriptors = {{
2087    HWC2_CALLBACK_HOTPLUG,
2088    HWC2_CALLBACK_REFRESH,
2089    HWC2_CALLBACK_VSYNC,
2090}};
2091
2092/* TESTCASE: Tests that the HWC2 can successfully register all required
2093 * callback functions. */
2094TEST_F(Hwc2Test, REGISTER_CALLBACK)
2095{
2096    hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2097            const_cast<char*>("data"));
2098
2099    for (auto descriptor : callbackDescriptors) {
2100        ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data,
2101                []() { return; }));
2102    }
2103}
2104
2105/* TESTCASE: Test that the HWC2 fails to register invalid callbacks. */
2106TEST_F(Hwc2Test, REGISTER_CALLBACK_bad_parameter)
2107{
2108    hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2109            const_cast<char*>("data"));
2110    hwc2_error_t err = HWC2_ERROR_NONE;
2111
2112    ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_INVALID, data,
2113            []() { return; }, &err));
2114    EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
2115}
2116
2117/* TESTCASE: Tests that the HWC2 can register a callback with null data. */
2118TEST_F(Hwc2Test, REGISTER_CALLBACK_null_data)
2119{
2120    hwc2_callback_data_t data = nullptr;
2121
2122    for (auto descriptor : callbackDescriptors) {
2123        ASSERT_NO_FATAL_FAILURE(registerCallback(descriptor, data,
2124                []() { return; }));
2125    }
2126}
2127
2128/* TESTCASE: Tests that the HWC2 returns the correct display type for each
2129 * physical display. */
2130TEST_F(Hwc2Test, GET_DISPLAY_TYPE)
2131{
2132    for (auto display : mDisplays) {
2133        hwc2_display_type_t type;
2134
2135        ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type));
2136        EXPECT_EQ(type, HWC2_DISPLAY_TYPE_PHYSICAL) << "failed to return"
2137                " correct display type";
2138    }
2139}
2140
2141/* TESTCASE: Tests that the HWC2 returns an error when the display type of a bad
2142 * display is requested. */
2143TEST_F(Hwc2Test, GET_DISPLAY_TYPE_bad_display)
2144{
2145    hwc2_display_t display;
2146    hwc2_display_type_t type;
2147    hwc2_error_t err = HWC2_ERROR_NONE;
2148
2149    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2150
2151    ASSERT_NO_FATAL_FAILURE(getDisplayType(display, &type, &err));
2152    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2153}
2154
2155/* TESTCASE: Tests that the HWC2 can create and destroy layers. */
2156TEST_F(Hwc2Test, CREATE_DESTROY_LAYER)
2157{
2158    for (auto display : mDisplays) {
2159        hwc2_layer_t layer;
2160
2161        ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
2162
2163        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
2164    }
2165}
2166
2167/* TESTCASE: Tests that the HWC2 cannot create a layer for a bad display */
2168TEST_F(Hwc2Test, CREATE_LAYER_bad_display)
2169{
2170    hwc2_display_t display;
2171    hwc2_layer_t layer;
2172    hwc2_error_t err = HWC2_ERROR_NONE;
2173
2174    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2175
2176    ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer, &err));
2177    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2178}
2179
2180/* TESTCASE: Tests that the HWC2 will either support a large number of resources
2181 * or will return no resources. */
2182TEST_F(Hwc2Test, CREATE_LAYER_no_resources)
2183{
2184    const size_t layerCnt = 1000;
2185
2186    for (auto display : mDisplays) {
2187        std::vector<hwc2_layer_t> layers;
2188
2189        ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
2190
2191        ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
2192    }
2193}
2194
2195/* TESTCASE: Tests that the HWC2 cannot destroy a layer for a bad display */
2196TEST_F(Hwc2Test, DESTROY_LAYER_bad_display)
2197{
2198    hwc2_display_t badDisplay;
2199
2200    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&badDisplay));
2201
2202    for (auto display : mDisplays) {
2203        hwc2_layer_t layer = 0;
2204        hwc2_error_t err = HWC2_ERROR_NONE;
2205
2206        ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err));
2207        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2208
2209        ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
2210
2211        ASSERT_NO_FATAL_FAILURE(destroyLayer(badDisplay, layer, &err));
2212        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2213
2214        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
2215    }
2216}
2217
2218/* TESTCASE: Tests that the HWC2 cannot destory a bad layer */
2219TEST_F(Hwc2Test, DESTROY_LAYER_bad_layer)
2220{
2221    for (auto display : mDisplays) {
2222        hwc2_layer_t layer;
2223        hwc2_error_t err = HWC2_ERROR_NONE;
2224
2225        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX / 2, &err));
2226        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2227
2228        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 0, &err));
2229        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2230
2231        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX - 1, &err));
2232        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2233
2234        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, 1, &err));
2235        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2236
2237        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, UINT64_MAX, &err));
2238        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2239
2240        ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
2241
2242        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer + 1, &err));
2243        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2244
2245        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
2246
2247        ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer, &err));
2248        EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";
2249    }
2250}
2251
2252static const std::array<hwc2_attribute_t, 2> requiredAttributes = {{
2253    HWC2_ATTRIBUTE_WIDTH,
2254    HWC2_ATTRIBUTE_HEIGHT,
2255}};
2256
2257static const std::array<hwc2_attribute_t, 3> optionalAttributes = {{
2258    HWC2_ATTRIBUTE_VSYNC_PERIOD,
2259    HWC2_ATTRIBUTE_DPI_X,
2260    HWC2_ATTRIBUTE_DPI_Y,
2261}};
2262
2263/* TESTCASE: Tests that the HWC2 can return display attributes for a valid
2264 * config. */
2265TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE)
2266{
2267    for (auto display : mDisplays) {
2268        std::vector<hwc2_config_t> configs;
2269
2270        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2271
2272        for (auto config : configs) {
2273            int32_t value;
2274
2275            for (auto attribute : requiredAttributes) {
2276                ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2277                        attribute, &value));
2278                EXPECT_GE(value, 0) << "missing required attribute "
2279                        << getAttributeName(attribute) << " for config "
2280                        << config;
2281            }
2282            for (auto attribute : optionalAttributes) {
2283                ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2284                        attribute, &value));
2285            }
2286        }
2287    }
2288}
2289
2290/* TESTCASE: Tests that the HWC2 will return a value of -1 for an invalid
2291 * attribute */
2292TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_invalid_attribute)
2293{
2294    const hwc2_attribute_t attribute = HWC2_ATTRIBUTE_INVALID;
2295
2296    for (auto display : mDisplays) {
2297        std::vector<hwc2_config_t> configs;
2298
2299        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2300
2301        for (auto config : configs) {
2302            int32_t value;
2303            hwc2_error_t err = HWC2_ERROR_NONE;
2304
2305            ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2306                    attribute, &value, &err));
2307            EXPECT_EQ(value, -1) << "failed to return -1 for an invalid"
2308                    " attribute for config " << config;
2309        }
2310    }
2311}
2312
2313/* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad display */
2314TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_display)
2315{
2316    hwc2_display_t display;
2317    const hwc2_config_t config = 0;
2318    int32_t value;
2319    hwc2_error_t err = HWC2_ERROR_NONE;
2320
2321    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2322
2323    for (auto attribute : requiredAttributes) {
2324        ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute,
2325                &value, &err));
2326        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2327    }
2328
2329    for (auto attribute : optionalAttributes) {
2330        ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config, attribute,
2331                &value, &err));
2332        EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2333    }
2334}
2335
2336/* TESTCASE: Tests that the HWC2 will fail to get attributes for a bad config */
2337TEST_F(Hwc2Test, GET_DISPLAY_ATTRIBUTE_bad_config)
2338{
2339    for (auto display : mDisplays) {
2340        hwc2_config_t config;
2341        int32_t value;
2342        hwc2_error_t err = HWC2_ERROR_NONE;
2343
2344        ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config));
2345
2346        for (auto attribute : requiredAttributes) {
2347            ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2348                    attribute, &value, &err));
2349            EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2350        }
2351
2352        for (auto attribute : optionalAttributes) {
2353            ASSERT_NO_FATAL_FAILURE(getDisplayAttribute(display, config,
2354                    attribute, &value, &err));
2355            EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2356        }
2357    }
2358}
2359
2360/* TESTCASE: Tests that the HWC2 will get display configs for active displays */
2361TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS)
2362{
2363    for (auto display : mDisplays) {
2364        std::vector<hwc2_config_t> configs;
2365
2366        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2367    }
2368}
2369
2370/* TESTCASE: Tests that the HWC2 will not get display configs for bad displays */
2371TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_bad_display)
2372{
2373    hwc2_display_t display;
2374    std::vector<hwc2_config_t> configs;
2375    hwc2_error_t err = HWC2_ERROR_NONE;
2376
2377    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2378
2379    ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs, &err));
2380
2381    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2382    EXPECT_TRUE(configs.empty()) << "returned configs for bad display";
2383}
2384
2385/* TESTCASE: Tests that the HWC2 will return the same config list multiple
2386 * times in a row. */
2387TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_same)
2388{
2389    for (auto display : mDisplays) {
2390        std::vector<hwc2_config_t> configs1, configs2;
2391
2392        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs1));
2393        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs2));
2394
2395        EXPECT_TRUE(std::is_permutation(configs1.begin(), configs1.end(),
2396                configs2.begin())) << "returned two different config sets";
2397    }
2398}
2399
2400/* TESTCASE: Tests that the HWC2 does not return duplicate display configs */
2401TEST_F(Hwc2Test, GET_DISPLAY_CONFIGS_duplicate)
2402{
2403    for (auto display : mDisplays) {
2404        std::vector<hwc2_config_t> configs;
2405
2406        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2407
2408        std::unordered_set<hwc2_config_t> configsSet(configs.begin(),
2409                configs.end());
2410        EXPECT_EQ(configs.size(), configsSet.size()) << "returned duplicate"
2411                " configs";
2412    }
2413}
2414
2415/* TESTCASE: Tests that the HWC2 returns the active config for a display */
2416TEST_F(Hwc2Test, GET_ACTIVE_CONFIG)
2417{
2418    for (auto display : mDisplays) {
2419        std::vector<hwc2_config_t> configs;
2420
2421        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2422
2423        for (auto config : configs) {
2424            hwc2_config_t activeConfig;
2425
2426            ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
2427            ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig));
2428
2429            EXPECT_EQ(activeConfig, config) << "failed to get active config";
2430        }
2431    }
2432}
2433
2434/* TESTCASE: Tests that the HWC2 does not return an active config for a bad
2435 * display. */
2436TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_display)
2437{
2438    hwc2_display_t display;
2439    hwc2_config_t activeConfig;
2440    hwc2_error_t err = HWC2_ERROR_NONE;
2441
2442    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2443
2444    ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err));
2445
2446    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2447}
2448
2449/* TESTCASE: Tests that the HWC2 either begins with a valid active config
2450 * or returns an error when getActiveConfig is called. */
2451TEST_F(Hwc2Test, GET_ACTIVE_CONFIG_bad_config)
2452{
2453    for (auto display : mDisplays) {
2454        std::vector<hwc2_config_t> configs;
2455        hwc2_config_t activeConfig;
2456        hwc2_error_t err = HWC2_ERROR_NONE;
2457
2458        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2459
2460        if (configs.empty())
2461            return;
2462
2463        ASSERT_NO_FATAL_FAILURE(getActiveConfig(display, &activeConfig, &err));
2464        if (err == HWC2_ERROR_NONE) {
2465            EXPECT_NE(std::count(configs.begin(), configs.end(),
2466                    activeConfig), 0) << "active config is not found in "
2467                    " configs for display";
2468        } else {
2469            EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2470        }
2471    }
2472}
2473
2474/* TESTCASE: Tests that the HWC2 can set every display config as an active
2475 * config */
2476TEST_F(Hwc2Test, SET_ACTIVE_CONFIG)
2477{
2478    for (auto display : mDisplays) {
2479        std::vector<hwc2_config_t> configs;
2480
2481        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
2482
2483        for (auto config : configs) {
2484            EXPECT_NO_FATAL_FAILURE(setActiveConfig(display, config));
2485        }
2486    }
2487}
2488
2489/* TESTCASE: Tests that the HWC2 cannot set an active config for a bad display */
2490TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_display)
2491{
2492    hwc2_display_t display;
2493    const hwc2_config_t config = 0;
2494    hwc2_error_t err = HWC2_ERROR_NONE;
2495
2496    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2497
2498    ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err));
2499    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2500}
2501
2502/* TESTCASE: Tests that the HWC2 cannot set an invalid active config */
2503TEST_F(Hwc2Test, SET_ACTIVE_CONFIG_bad_config)
2504{
2505    for (auto display : mDisplays) {
2506        hwc2_config_t config;
2507        hwc2_error_t err = HWC2_ERROR_NONE;
2508
2509        ASSERT_NO_FATAL_FAILURE(getInvalidConfig(display, &config));
2510
2511        ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config, &err));
2512        EXPECT_EQ(err, HWC2_ERROR_BAD_CONFIG) << "returned wrong error code";
2513    }
2514}
2515
2516/* TESTCASE: Tests that the HWC2 returns a valid value for getDozeSupport. */
2517TEST_F(Hwc2Test, GET_DOZE_SUPPORT)
2518{
2519    for (auto display : mDisplays) {
2520        int32_t support = -1;
2521
2522        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
2523
2524        EXPECT_TRUE(support == 0 || support == 1) << "invalid doze support value";
2525    }
2526}
2527
2528/* TESTCASE: Tests that the HWC2 cannot get doze support for a bad display. */
2529TEST_F(Hwc2Test, GET_DOZE_SUPPORT_bad_display)
2530{
2531    hwc2_display_t display;
2532    int32_t support = -1;
2533    hwc2_error_t err = HWC2_ERROR_NONE;
2534
2535    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2536
2537    ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
2538
2539    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2540}
2541
2542/* TESTCASE: Tests that the HWC2 can set all supported power modes */
2543TEST_F(Hwc2Test, SET_POWER_MODE)
2544{
2545    for (auto display : mDisplays) {
2546        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2547        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2548
2549        int32_t support = -1;
2550        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
2551        if (support != 1)
2552            return;
2553
2554        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
2555        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2556                HWC2_POWER_MODE_DOZE_SUSPEND));
2557
2558        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2559    }
2560}
2561
2562/* TESTCASE: Tests that the HWC2 cannot set a power mode for a bad display. */
2563TEST_F(Hwc2Test, SET_POWER_MODE_bad_display)
2564{
2565    hwc2_display_t display;
2566    hwc2_error_t err = HWC2_ERROR_NONE;
2567
2568    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2569
2570    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON, &err));
2571    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2572
2573    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF, &err));
2574    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2575
2576    int32_t support = -1;
2577    ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
2578    if (support != 1)
2579        return;
2580
2581    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE, &err));
2582    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2583
2584    ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE_SUSPEND,
2585            &err));
2586    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2587}
2588
2589/* TESTCASE: Tests that the HWC2 cannot set an invalid power mode value. */
2590TEST_F(Hwc2Test, SET_POWER_MODE_bad_parameter)
2591{
2592    for (auto display : mDisplays) {
2593        hwc2_power_mode_t mode = static_cast<hwc2_power_mode_t>(
2594                HWC2_POWER_MODE_DOZE_SUSPEND + 1);
2595        hwc2_error_t err = HWC2_ERROR_NONE;
2596
2597        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, mode, &err));
2598        EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code "
2599                << mode;
2600    }
2601}
2602
2603/* TESTCASE: Tests that the HWC2 will return unsupported if it does not support
2604 * an optional power mode. */
2605TEST_F(Hwc2Test, SET_POWER_MODE_unsupported)
2606{
2607    for (auto display : mDisplays) {
2608        int32_t support = -1;
2609        hwc2_error_t err = HWC2_ERROR_NONE;
2610
2611        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support, &err));
2612        if (support == 1)
2613            return;
2614
2615        ASSERT_EQ(support, 0) << "invalid doze support value";
2616
2617        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE,
2618                &err));
2619        EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
2620
2621        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2622                HWC2_POWER_MODE_DOZE_SUSPEND, &err));
2623        EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) <<  "returned wrong error code";
2624    }
2625}
2626
2627/* TESTCASE: Tests that the HWC2 can set the same power mode multiple times. */
2628TEST_F(Hwc2Test, SET_POWER_MODE_stress)
2629{
2630    for (auto display : mDisplays) {
2631        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2632        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2633
2634        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2635        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2636
2637        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2638        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2639
2640        int32_t support = -1;
2641        ASSERT_NO_FATAL_FAILURE(getDozeSupport(display, &support));
2642        if (support != 1)
2643            return;
2644
2645        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
2646        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_DOZE));
2647
2648        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2649                HWC2_POWER_MODE_DOZE_SUSPEND));
2650        ASSERT_NO_FATAL_FAILURE(setPowerMode(display,
2651                HWC2_POWER_MODE_DOZE_SUSPEND));
2652
2653        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2654    }
2655}
2656
2657/* TESTCASE: Tests that the HWC2 can enable and disable vsync on active
2658 * displays */
2659TEST_F(Hwc2Test, SET_VSYNC_ENABLED)
2660{
2661    for (auto display : mDisplays) {
2662        hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2663                const_cast<char*>("data"));
2664
2665        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2666
2667        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2668                []() { return; }));
2669
2670        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2671
2672        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2673
2674        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2675    }
2676}
2677
2678/* TESTCASE: Tests that the HWC2 issues a valid vsync callback. */
2679TEST_F(Hwc2Test, SET_VSYNC_ENABLED_callback)
2680{
2681    for (auto display : mDisplays) {
2682        hwc2_display_t receivedDisplay;
2683        int64_t receivedTimestamp;
2684
2685        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2686
2687        ASSERT_NO_FATAL_FAILURE(enableVsync(display));
2688
2689        ASSERT_NO_FATAL_FAILURE(waitForVsync(&receivedDisplay,
2690                &receivedTimestamp));
2691
2692        EXPECT_EQ(receivedDisplay, display) << "failed to get correct display";
2693        EXPECT_GE(receivedTimestamp, 0) << "failed to get valid timestamp";
2694
2695        ASSERT_NO_FATAL_FAILURE(disableVsync(display));
2696
2697        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2698    }
2699}
2700
2701/* TESTCASE: Tests that the HWC2 cannot enable a vsync for a bad display */
2702TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_display)
2703{
2704    hwc2_display_t display;
2705    hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2706            const_cast<char*>("data"));
2707    hwc2_error_t err = HWC2_ERROR_NONE;
2708
2709    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2710
2711    ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2712            []() { return; }));
2713
2714    ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE, &err));
2715    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2716
2717    ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE, &err));
2718    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2719}
2720
2721/* TESTCASE: Tests that the HWC2 cannot enable an invalid vsync value */
2722TEST_F(Hwc2Test, SET_VSYNC_ENABLED_bad_parameter)
2723{
2724    for (auto display : mDisplays) {
2725        hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2726                const_cast<char*>("data"));
2727        hwc2_error_t err = HWC2_ERROR_NONE;
2728
2729        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2730
2731        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2732                []() { return; }));
2733
2734        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_INVALID,
2735                &err));
2736        EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
2737
2738        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2739    }
2740}
2741
2742/* TESTCASE: Tests that the HWC2 can enable and disable a vsync value multiple
2743 * times. */
2744TEST_F(Hwc2Test, SET_VSYNC_ENABLED_stress)
2745{
2746    for (auto display : mDisplays) {
2747        hwc2_callback_data_t data = reinterpret_cast<hwc2_callback_data_t>(
2748                const_cast<char*>("data"));
2749
2750        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2751
2752        ASSERT_NO_FATAL_FAILURE(registerCallback(HWC2_CALLBACK_VSYNC, data,
2753                []() { return; }));
2754
2755        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2756
2757        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2758        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2759
2760        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2761        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2762
2763        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2764    }
2765}
2766
2767/* TESTCASE: Tests that the HWC2 can set a vsync enable value when the display
2768 * is off and no callback is registered. */
2769TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback_no_power)
2770{
2771    const uint secs = 1;
2772
2773    for (auto display : mDisplays) {
2774        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_ENABLE));
2775
2776        sleep(secs);
2777
2778        ASSERT_NO_FATAL_FAILURE(setVsyncEnabled(display, HWC2_VSYNC_DISABLE));
2779    }
2780}
2781
2782/* TESTCASE: Tests that the HWC2 can set a vsync enable value when no callback
2783 * is registered. */
2784TEST_F(Hwc2Test, SET_VSYNC_ENABLED_no_callback)
2785{
2786    const uint secs = 1;
2787
2788    for (auto display : mDisplays) {
2789        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
2790
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        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
2798    }
2799}
2800
2801/* TESTCASE: Tests that the HWC2 returns a display name for each display */
2802TEST_F(Hwc2Test, GET_DISPLAY_NAME)
2803{
2804    for (auto display : mDisplays) {
2805        std::string name;
2806
2807        ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name));
2808    }
2809}
2810
2811/* TESTCASE: Tests that the HWC2 does not return a display name for a bad
2812 * display */
2813TEST_F(Hwc2Test, GET_DISPLAY_NAME_bad_display)
2814{
2815    hwc2_display_t display;
2816    std::string name;
2817    hwc2_error_t err = HWC2_ERROR_NONE;
2818
2819    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2820
2821    ASSERT_NO_FATAL_FAILURE(getDisplayName(display, &name, &err));
2822    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2823}
2824
2825/* TESTCASE: Tests that the HWC2 can set basic composition types. */
2826TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE)
2827{
2828    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2829            setComposition, advanceComposition));
2830}
2831
2832/* TESTCASE: Tests that the HWC2 can update a basic composition type on a
2833 * layer. */
2834TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_update)
2835{
2836    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2837            setComposition, advanceComposition));
2838}
2839
2840/* TESTCASE: Tests that the HWC2 cannot set a composition type for a bad layer */
2841TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_layer)
2842{
2843    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2844            setComposition));
2845}
2846
2847/* TESTCASE: Tests that the HWC2 cannot set a bad composition type */
2848TEST_F(Hwc2Test, SET_LAYER_COMPOSITION_TYPE_bad_parameter)
2849{
2850    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
2851            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
2852                    hwc2_error_t* outErr) {
2853
2854                ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,
2855                        layer, HWC2_COMPOSITION_INVALID, outErr));
2856            }
2857    ));
2858}
2859
2860/* TESTCASE: Tests that the HWC2 can set the cursor position of a layer. */
2861TEST_F(Hwc2Test, SET_CURSOR_POSITION)
2862{
2863    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2864            ::setCursorPosition, advanceCursorPosition));
2865}
2866
2867/* TESTCASE: Tests that the HWC2 can update the cursor position of a layer. */
2868TEST_F(Hwc2Test, SET_CURSOR_POSITION_update)
2869{
2870    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2871            ::setCursorPosition, advanceCursorPosition));
2872}
2873
2874/* TESTCASE: Tests that the HWC2 can set the cursor position of a layer when the
2875 * composition type has not been set to HWC2_COMPOSITION_CURSOR. */
2876TEST_F(Hwc2Test, SET_CURSOR_POSITION_composition_type_unset)
2877{
2878    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2879            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
2880                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
2881
2882                const hwc_rect_t cursorPosition = testLayer->getCursorPosition();
2883                EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer,
2884                        cursorPosition.left, cursorPosition.top, outErr));
2885            },
2886
2887            advanceCursorPosition));
2888}
2889
2890/* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad
2891 * display. */
2892TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_display)
2893{
2894    hwc2_display_t display;
2895    hwc2_layer_t layer = 0;
2896    int32_t x = 0, y = 0;
2897    hwc2_error_t err = HWC2_ERROR_NONE;
2898
2899    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
2900
2901    ASSERT_NO_FATAL_FAILURE(setCursorPosition(display, layer, x, y, &err));
2902    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
2903}
2904
2905/* TESTCASE: Tests that the HWC2 cannot set the cursor position of a bad layer. */
2906TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_layer)
2907{
2908    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2909            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
2910                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
2911
2912                const hwc_rect_t cursorPosition = testLayer->getCursorPosition();
2913                EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display,
2914                        badLayer, cursorPosition.left, cursorPosition.top,
2915                        outErr));
2916            }
2917   ));
2918}
2919
2920/* TESTCASE: Tests that the HWC2 can set a blend mode value of a layer. */
2921TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE)
2922{
2923    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2924            setBlendMode, advanceBlendMode));
2925}
2926
2927/* TESTCASE: Tests that the HWC2 can update a blend mode value of a layer. */
2928TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_update)
2929{
2930    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2931            setBlendMode, advanceBlendMode));
2932}
2933
2934/* TESTCASE: Tests that the HWC2 cannot set a blend mode for a bad layer. */
2935TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_layer)
2936{
2937    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2938            setBlendMode));
2939}
2940
2941/* TESTCASE: Tests that the HWC2 cannot set an invalid blend mode. */
2942TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_parameter)
2943{
2944    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
2945            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
2946                    hwc2_error_t* outErr) {
2947
2948                ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display,
2949                        layer, HWC2_BLEND_MODE_INVALID, outErr));
2950            }
2951    ));
2952}
2953
2954/* TESTCASE: Tests that the HWC2 can set the buffer of a layer. */
2955TEST_F(Hwc2Test, SET_LAYER_BUFFER)
2956{
2957    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
2958            setBuffer, advanceBuffer));
2959}
2960
2961/* TESTCASE: Tests that the HWC2 can update the buffer of a layer. */
2962TEST_F(Hwc2Test, SET_LAYER_BUFFER_update)
2963{
2964    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
2965            setBuffer, advanceBuffer));
2966}
2967
2968/* TESTCASE: Tests that the HWC2 cannot set the buffer of a bad layer. */
2969TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_layer)
2970{
2971    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
2972            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
2973                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
2974
2975                buffer_handle_t handle = nullptr;
2976                android::base::unique_fd acquireFence;
2977
2978                /* If there is not available buffer for the given buffer
2979                 * properties, it should not fail this test case */
2980                if (testLayer->getBuffer(&handle, &acquireFence) == 0) {
2981                    *outErr = HWC2_ERROR_BAD_LAYER;
2982                    return;
2983                }
2984
2985                ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, badLayer,
2986                        handle, acquireFence, outErr));
2987            }
2988    ));
2989}
2990
2991/* TESTCASE: Tests that the HWC2 can set an invalid buffer for a layer. */
2992TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_parameter)
2993{
2994    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(
2995            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
2996                    hwc2_error_t* outErr) {
2997
2998                buffer_handle_t handle = nullptr;
2999                int32_t acquireFence = -1;
3000
3001                ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer,
3002                        handle, acquireFence, outErr));
3003            }
3004    ));
3005}
3006
3007/* TESTCASE: Tests that the HWC2 can set the color of a layer. */
3008TEST_F(Hwc2Test, SET_LAYER_COLOR)
3009{
3010    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3011            setColor, advanceColor));
3012}
3013
3014/* TESTCASE: Tests that the HWC2 can update the color of a layer. */
3015TEST_F(Hwc2Test, SET_LAYER_COLOR_update)
3016{
3017    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3018            setColor, advanceColor));
3019}
3020
3021/* TESTCASE: Tests that the HWC2 can set the color of a layer when the
3022 * composition type has not been set to HWC2_COMPOSITION_SOLID_COLOR. */
3023TEST_F(Hwc2Test, SET_LAYER_COLOR_composition_type_unset)
3024{
3025    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Basic,
3026            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
3027                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
3028
3029                EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,
3030                        testLayer->getColor(), outErr));
3031            },
3032
3033            advanceColor));
3034}
3035
3036/* TESTCASE: Tests that the HWC2 cannot set the color of a bad layer. */
3037TEST_F(Hwc2Test, SET_LAYER_COLOR_bad_layer)
3038{
3039    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3040            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
3041                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {
3042
3043                EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, badLayer,
3044                        testLayer->getColor(), outErr));
3045            }
3046    ));
3047}
3048
3049/* TESTCASE: Tests that the HWC2 can set the dataspace of a layer. */
3050TEST_F(Hwc2Test, SET_LAYER_DATASPACE)
3051{
3052    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3053            setDataspace, advanceDataspace));
3054}
3055
3056/* TESTCASE: Tests that the HWC2 can update the dataspace of a layer. */
3057TEST_F(Hwc2Test, SET_LAYER_DATASPACE_update)
3058{
3059    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3060            setDataspace, advanceDataspace));
3061}
3062
3063/* TESTCASE: Tests that the HWC2 cannot set a dataspace for a bad layer. */
3064TEST_F(Hwc2Test, SET_LAYER_DATASPACE_bad_layer)
3065{
3066    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3067            setDataspace));
3068}
3069
3070/* TESTCASE: Tests that the HWC2 can set the display frame of a layer. */
3071TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME)
3072{
3073    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3074            setDisplayFrame, advanceDisplayFrame));
3075}
3076
3077/* TESTCASE: Tests that the HWC2 can update the display frame of a layer. */
3078TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_update)
3079{
3080    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3081            setDisplayFrame, advanceDisplayFrame));
3082}
3083
3084/* TESTCASE: Tests that the HWC2 cannot set the display frame of a bad layer. */
3085TEST_F(Hwc2Test, SET_LAYER_DISPLAY_FRAME_bad_layer)
3086{
3087    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3088            setDisplayFrame));
3089}
3090
3091/* TESTCASE: Tests that the HWC2 can set the plane alpha of a layer. */
3092TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA)
3093{
3094    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3095            setPlaneAlpha, advancePlaneAlpha));
3096}
3097
3098/* TESTCASE: Tests that the HWC2 can update the plane alpha of a layer. */
3099TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_update)
3100{
3101    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3102            setPlaneAlpha, advancePlaneAlpha));
3103}
3104
3105/* TESTCASE: Tests that the HWC2 cannot set a plane alpha for a bad layer. */
3106TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_bad_layer)
3107{
3108    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3109            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,
3110                    Hwc2TestLayer* testLayer, hwc2_error_t *outErr) {
3111
3112                    EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,
3113                            badLayer, testLayer->getPlaneAlpha(), outErr));
3114            }
3115    ));
3116}
3117
3118/* TESTCASE: Tests that the HWC2 can set the source crop of a layer. */
3119TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP)
3120{
3121    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3122            setSourceCrop, advanceSourceCrop));
3123}
3124
3125/* TESTCASE: Tests that the HWC2 can update the source crop of a layer. */
3126TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_update)
3127{
3128    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3129            setSourceCrop, advanceSourceCrop));
3130}
3131
3132/* TESTCASE: Tests that the HWC2 cannot set the source crop of a bad layer. */
3133TEST_F(Hwc2Test, SET_LAYER_SOURCE_CROP_bad_layer)
3134{
3135    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3136            setSourceCrop));
3137}
3138
3139/* TESTCASE: Tests that the HWC2 can set the surface damage of a layer. */
3140TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE)
3141{
3142    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3143            setSurfaceDamage, advanceSurfaceDamage));
3144}
3145
3146/* TESTCASE: Tests that the HWC2 can update the surface damage of a layer. */
3147TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_update)
3148{
3149    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3150            setSurfaceDamage, advanceSurfaceDamage));
3151}
3152
3153/* TESTCASE: Tests that the HWC2 cannot set the surface damage of a bad layer. */
3154TEST_F(Hwc2Test, SET_LAYER_SURFACE_DAMAGE_bad_layer)
3155{
3156    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3157            setSurfaceDamage));
3158}
3159
3160/* TESTCASE: Tests that the HWC2 can set the transform value of a layer. */
3161TEST_F(Hwc2Test, SET_LAYER_TRANSFORM)
3162{
3163    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,
3164            setTransform, advanceTransform));
3165}
3166
3167/* TESTCASE: Tests that the HWC2 can update the transform value of a layer. */
3168TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_update)
3169{
3170    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,
3171            setTransform, advanceTransform));
3172}
3173
3174/* TESTCASE: Tests that the HWC2 cannot set the transform for a bad layer. */
3175TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_bad_layer)
3176{
3177    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3178            setTransform));
3179}
3180
3181/* TESTCASE: Tests that the HWC2 can set the visible region of a layer. */
3182TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION)
3183{
3184    ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Basic, 5,
3185            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
3186                    Hwc2TestLayers* testLayers) {
3187
3188                EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display,
3189                        layer, testLayers->getVisibleRegion(layer)));
3190            },
3191
3192            advanceVisibleRegions));
3193}
3194
3195/* TESTCASE: Tests that the HWC2 cannot set the visible region of a bad layer. */
3196TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION_bad_layer)
3197{
3198    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3199            setVisibleRegion));
3200}
3201
3202/* TESTCASE: Tests that the HWC2 can set the z order of a layer. */
3203TEST_F(Hwc2Test, SET_LAYER_Z_ORDER)
3204{
3205    ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Complete, 10,
3206            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,
3207                    Hwc2TestLayers* testLayers) {
3208
3209                EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,
3210                        testLayers->getZOrder(layer)));
3211            },
3212
3213            /* TestLayer z orders are set during the construction of TestLayers
3214             * and cannot be updated. There is no need (or ability) to cycle
3215             * through additional z order configurations. */
3216            [] (Hwc2TestLayers* /*testLayers*/) {
3217                return false;
3218            }
3219    ));
3220}
3221
3222/* TESTCASE: Tests that the HWC2 can update the z order of a layer. */
3223TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_update)
3224{
3225    const std::vector<uint32_t> zOrders = { static_cast<uint32_t>(0),
3226            static_cast<uint32_t>(1), static_cast<uint32_t>(UINT32_MAX / 4),
3227            static_cast<uint32_t>(UINT32_MAX / 2),
3228            static_cast<uint32_t>(UINT32_MAX) };
3229
3230    for (auto display : mDisplays) {
3231        std::vector<hwc2_config_t> configs;
3232
3233        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
3234
3235        for (auto config : configs) {
3236            hwc2_layer_t layer;
3237
3238            ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
3239
3240            ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));
3241
3242            for (uint32_t zOrder : zOrders) {
3243                EXPECT_NO_FATAL_FAILURE(setLayerZOrder(display, layer, zOrder));
3244            }
3245
3246            ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
3247        }
3248    }
3249}
3250
3251/* TESTCASE: Tests that the HWC2 cannot set the z order of a bad layer. */
3252TEST_F(Hwc2Test, SET_LAYER_Z_ORDER_bad_layer)
3253{
3254    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,
3255            setZOrder));
3256}
3257
3258/* TESTCASE: Tests that the HWC2 can display a layer with basic property
3259 * coverage */
3260TEST_F(Hwc2Test, VALIDATE_DISPLAY_basic)
3261{
3262    ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3263            [] (Hwc2Test* test, hwc2_display_t display,
3264                    const std::vector<hwc2_layer_t>& layers,
3265                    Hwc2TestLayers* /*testLayers*/) {
3266
3267                uint32_t numTypes, numRequests;
3268                bool hasChanges = false;
3269
3270                EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3271                        &numRequests, &hasChanges));
3272                if (hasChanges)
3273                    EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size()))
3274                            << "wrong number of requests";
3275            }
3276    ));
3277}
3278
3279/* TESTCASE: Tests that the HWC2 can display 5 layers with default coverage. */
3280TEST_F(Hwc2Test, VALIDATE_DISPLAY_default_5)
3281{
3282    ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 5,
3283            [] (Hwc2Test* test, hwc2_display_t display,
3284                    const std::vector<hwc2_layer_t>& layers,
3285                    Hwc2TestLayers* /*testLayers*/) {
3286
3287                uint32_t numTypes, numRequests;
3288                bool hasChanges = false;
3289
3290                EXPECT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3291                        &numRequests, &hasChanges));
3292                if (hasChanges)
3293                    EXPECT_LE(numTypes, static_cast<uint32_t>(layers.size()))
3294                            << "wrong number of requests";
3295            }
3296    ));
3297}
3298
3299/* TESTCASE: Tests that the HWC2 cannot validate a bad display */
3300TEST_F(Hwc2Test, VALIDATE_DISPLAY_bad_display)
3301{
3302    hwc2_display_t display;
3303    uint32_t numTypes, numRequests;
3304    hwc2_error_t err = HWC2_ERROR_NONE;
3305
3306    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3307
3308    ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes, &numRequests,
3309            &err));
3310    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3311}
3312
3313/* TESTCASE: Tests that the HWC2 can get display requests after validating a
3314 * basic layer. */
3315TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_basic)
3316{
3317    ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3318            [] (Hwc2Test* test, hwc2_display_t display,
3319                    const std::vector<hwc2_layer_t>& layers,
3320                    Hwc2TestLayers* /*testLayers*/) {
3321
3322                uint32_t numTypes, numRequests;
3323                bool hasChanges = false;
3324
3325                ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3326                        &numRequests, &hasChanges));
3327                if (hasChanges)
3328                    EXPECT_LE(numTypes, layers.size())
3329                            << "wrong number of requests";
3330
3331                EXPECT_NO_FATAL_FAILURE(test->handleRequests(display, layers,
3332                        numRequests));
3333            }
3334    ));
3335}
3336
3337/* TESTCASE: Tests that the HWC2 cannot get display requests from a bad display */
3338TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_bad_display)
3339{
3340    hwc2_display_t display;
3341    hwc2_display_request_t displayRequests;
3342    std::vector<hwc2_layer_t> layers;
3343    std::vector<hwc2_layer_request_t> layerRequests;
3344    hwc2_error_t err = HWC2_ERROR_NONE;
3345
3346    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3347
3348    EXPECT_NO_FATAL_FAILURE(getDisplayRequests(display, &displayRequests,
3349            &layers, &layerRequests, &err));
3350    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3351}
3352
3353/* TESTCASE: Tests that the HWC2 cannot get display requests from an non
3354 * validated display. */
3355TEST_F(Hwc2Test, GET_DISPLAY_REQUESTS_not_validated)
3356{
3357    ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5,
3358            [] (Hwc2Test* test, hwc2_display_t display,
3359                    std::vector<hwc2_layer_t>* layers) {
3360
3361                hwc2_display_request_t displayRequests;
3362                std::vector<hwc2_layer_request_t> layerRequests;
3363                hwc2_error_t err = HWC2_ERROR_NONE;
3364
3365                ASSERT_NO_FATAL_FAILURE(test->getDisplayRequests(display,
3366                        &displayRequests, layers, &layerRequests, &err));
3367                EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
3368                        << "returned wrong error code";
3369            }
3370    ));
3371}
3372
3373/* TESTCASE: Tests that the HWC2 can get changed composition types after
3374 * validating a basic layer. */
3375TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_basic)
3376{
3377    ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3378            [] (Hwc2Test* test, hwc2_display_t display,
3379                    const std::vector<hwc2_layer_t>& layers,
3380                    Hwc2TestLayers* testLayers) {
3381
3382                uint32_t numTypes, numRequests;
3383                bool hasChanges = false;
3384
3385                ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3386                        &numRequests, &hasChanges));
3387                if (hasChanges)
3388                    EXPECT_LE(numTypes, layers.size())
3389                            << "wrong number of requests";
3390
3391                EXPECT_NO_FATAL_FAILURE(test->handleCompositionChanges(display,
3392                        *testLayers, layers, numTypes));
3393            }
3394    ));
3395}
3396
3397/* TESTCASE: Tests that the HWC2 cannot get changed composition types from a bad
3398 * display */
3399TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_bad_display)
3400{
3401    hwc2_display_t display;
3402    std::vector<hwc2_layer_t> layers;
3403    std::vector<hwc2_composition_t> types;
3404    hwc2_error_t err = HWC2_ERROR_NONE;
3405
3406    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3407
3408    EXPECT_NO_FATAL_FAILURE(getChangedCompositionTypes(display, &layers,
3409            &types, &err));
3410    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3411}
3412
3413/* TESTCASE: Tests that the HWC2 cannot get changed composition types from an non
3414 * validated display. */
3415TEST_F(Hwc2Test, GET_CHANGED_COMPOSITION_TYPES_not_validated)
3416{
3417    ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5,
3418            [] (Hwc2Test* test, hwc2_display_t display,
3419                    std::vector<hwc2_layer_t>* layers) {
3420
3421                std::vector<hwc2_composition_t> types;
3422                hwc2_error_t err = HWC2_ERROR_NONE;
3423
3424                ASSERT_NO_FATAL_FAILURE(test->getChangedCompositionTypes(
3425                        display, layers, &types, &err));
3426                EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
3427                        << "returned wrong error code";
3428            }
3429    ));
3430}
3431
3432/* TESTCASE: Tests that the HWC2 can accept display changes after validating a
3433 * basic layer. */
3434TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_basic)
3435{
3436    ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Basic, 1,
3437            [] (Hwc2Test* test, hwc2_display_t display,
3438                    const std::vector<hwc2_layer_t>& layers,
3439                    Hwc2TestLayers* testLayers) {
3440
3441                uint32_t numTypes, numRequests;
3442                bool hasChanges = false;
3443
3444                ASSERT_NO_FATAL_FAILURE(test->validateDisplay(display, &numTypes,
3445                        &numRequests, &hasChanges));
3446                if (hasChanges)
3447                    EXPECT_LE(numTypes, layers.size())
3448                            << "wrong number of requests";
3449
3450                ASSERT_NO_FATAL_FAILURE(test->handleCompositionChanges(display,
3451                        *testLayers, layers, numTypes));
3452
3453                EXPECT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display));
3454            }
3455    ));
3456}
3457
3458/* TESTCASE: Tests that the HWC2 cannot accept display changes from a bad
3459 * display */
3460TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_bad_display)
3461{
3462    hwc2_display_t display;
3463    hwc2_error_t err = HWC2_ERROR_NONE;
3464
3465    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3466
3467    EXPECT_NO_FATAL_FAILURE(acceptDisplayChanges(display, &err));
3468    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3469}
3470
3471/* TESTCASE: Tests that the HWC2 cannot accept display changes from an non
3472 * validated display. */
3473TEST_F(Hwc2Test, ACCEPT_DISPLAY_CHANGES_not_validated)
3474{
3475    ASSERT_NO_FATAL_FAILURE(displayNonValidatedLayers(5,
3476            [] (Hwc2Test* test, hwc2_display_t display,
3477                    std::vector<hwc2_layer_t>* /*layers*/) {
3478
3479                hwc2_error_t err = HWC2_ERROR_NONE;
3480
3481                ASSERT_NO_FATAL_FAILURE(test->acceptDisplayChanges(display, &err));
3482                EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
3483                        << "returned wrong error code";
3484            }
3485    ));
3486}
3487
3488/* TESTCASE: Tests that the HWC2 supports client target with required values */
3489TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT)
3490{
3491    ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default,
3492            [] (Hwc2Test* test, hwc2_display_t display,
3493                    const Hwc2TestClientTargetSupport& testClientTargetSupport) {
3494
3495                const Area bufferArea = testClientTargetSupport.getBufferArea();
3496                const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888;
3497
3498                ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display,
3499                        bufferArea.width, bufferArea.height, format,
3500                        testClientTargetSupport.getDataspace()));
3501            },
3502
3503            advanceClientTargetSupport));
3504}
3505
3506/* TESTCASE: Tests that the HWC2 cannot get client target support for a bad
3507 * display. */
3508TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_bad_display)
3509{
3510    ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Default,
3511            [] (Hwc2Test* test, hwc2_display_t /*display*/,
3512                    const Hwc2TestClientTargetSupport& testClientTargetSupport) {
3513
3514                const Area bufferArea = testClientTargetSupport.getBufferArea();
3515                const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888;
3516                hwc2_display_t badDisplay;
3517                hwc2_error_t err = HWC2_ERROR_NONE;
3518
3519                ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay));
3520
3521                ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(badDisplay,
3522                        bufferArea.width, bufferArea.height, format,
3523                        testClientTargetSupport.getDataspace(), &err));
3524                EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3525            },
3526
3527            advanceClientTargetSupport));
3528}
3529
3530/* TESTCASE: Tests that the HWC2 either supports or returns error unsupported
3531 * for a variety of client target values. */
3532TEST_F(Hwc2Test, GET_CLIENT_TARGET_SUPPORT_unsupported)
3533{
3534    ASSERT_NO_FATAL_FAILURE(setClientTargetSupport(Hwc2TestCoverage::Complete,
3535            [] (Hwc2Test* test, hwc2_display_t display,
3536                    const Hwc2TestClientTargetSupport& testClientTargetSupport) {
3537
3538                const Area bufferArea = testClientTargetSupport.getBufferArea();
3539                const android_pixel_format_t format = HAL_PIXEL_FORMAT_RGBA_8888;
3540                hwc2_error_t err = HWC2_ERROR_NONE;
3541
3542                ASSERT_NO_FATAL_FAILURE(test->getClientTargetSupport(display,
3543                        bufferArea.width, bufferArea.height, format,
3544                        testClientTargetSupport.getDataspace(), &err));
3545                EXPECT_TRUE(err == HWC2_ERROR_NONE
3546                        || err == HWC2_ERROR_UNSUPPORTED)
3547                        << "returned wrong error code";
3548            },
3549
3550            advanceClientTargetSupport));
3551}
3552
3553/* TESTCASE: Tests that the HWC2 can set a client target buffer for a basic
3554 * layer. */
3555TEST_F(Hwc2Test, SET_CLIENT_TARGET_basic)
3556{
3557    const android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN;
3558    const hwc_region_t damage = { };
3559    const size_t layerCnt = 1;
3560
3561    for (auto display : mDisplays) {
3562        std::vector<hwc2_config_t> configs;
3563
3564        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_ON));
3565
3566        ASSERT_NO_FATAL_FAILURE(getDisplayConfigs(display, &configs));
3567
3568        for (auto config : configs) {
3569            Area displayArea;
3570            std::vector<hwc2_layer_t> layers;
3571
3572            ASSERT_NO_FATAL_FAILURE(setActiveConfig(display, config));
3573            ASSERT_NO_FATAL_FAILURE(getActiveDisplayArea(display, &displayArea));
3574
3575            ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));
3576            Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Basic,
3577                    displayArea);
3578
3579            if (!testLayers.optimizeLayouts())
3580                continue;
3581
3582            Hwc2TestClientTarget testClientTarget;
3583
3584            do {
3585                std::set<hwc2_layer_t> clientLayers;
3586                std::set<hwc2_layer_t> clearLayers;
3587                uint32_t numTypes, numRequests;
3588                bool hasChanges, skip;
3589                bool flipClientTarget;
3590                buffer_handle_t handle;
3591                int32_t acquireFence;
3592
3593                ASSERT_NO_FATAL_FAILURE(setLayerProperties(display, layers,
3594                        &testLayers, &skip));
3595                if (skip)
3596                    continue;
3597
3598                ASSERT_NO_FATAL_FAILURE(validateDisplay(display, &numTypes,
3599                        &numRequests, &hasChanges));
3600                if (hasChanges)
3601                    EXPECT_LE(numTypes, layers.size())
3602                            << "wrong number of requests";
3603
3604                ASSERT_NO_FATAL_FAILURE(handleCompositionChanges(display,
3605                        testLayers, layers, numTypes, &clientLayers));
3606                ASSERT_NO_FATAL_FAILURE(handleRequests(display, layers,
3607                        numRequests, &clearLayers, &flipClientTarget));
3608                ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers,
3609                        clearLayers, flipClientTarget, displayArea, &handle,
3610                        &acquireFence), 0);
3611                EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle,
3612                        acquireFence, dataspace, damage));
3613
3614                if (acquireFence >= 0)
3615                    close(acquireFence);
3616
3617            } while (testLayers.advance());
3618
3619            ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
3620        }
3621
3622        ASSERT_NO_FATAL_FAILURE(setPowerMode(display, HWC2_POWER_MODE_OFF));
3623    }
3624}
3625
3626/* TESTCASE: Tests that the HWC2 cannot set a client target for a bad display. */
3627TEST_F(Hwc2Test, SET_CLIENT_TARGET_bad_display)
3628{
3629    hwc2_display_t display;
3630    std::vector<hwc2_layer_t> layers;
3631    const Area displayArea = {0, 0};
3632    Hwc2TestLayers testLayers(layers, Hwc2TestCoverage::Default, displayArea);
3633    std::set<hwc2_layer_t> clientLayers;
3634    std::set<hwc2_layer_t> flipClientTargetLayers;
3635    bool flipClientTarget = true;
3636    const android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN;
3637    const hwc_region_t damage = { };
3638    buffer_handle_t handle;
3639    int32_t acquireFence;
3640    hwc2_error_t err = HWC2_ERROR_NONE;
3641
3642    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
3643
3644    Hwc2TestClientTarget testClientTarget;
3645
3646    ASSERT_EQ(testClientTarget.getBuffer(testLayers, clientLayers,
3647            flipClientTargetLayers, flipClientTarget, displayArea, &handle,
3648            &acquireFence), 0);
3649
3650    EXPECT_NO_FATAL_FAILURE(setClientTarget(display, handle, acquireFence,
3651            dataspace, damage, &err));
3652
3653    if (acquireFence >= 0)
3654        close(acquireFence);
3655
3656    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
3657}
3658
3659/* TESTCASE: Tests that the HWC2 can present 1 default layer. */
3660TEST_F(Hwc2Test, PRESENT_DISPLAY_default_1)
3661{
3662    const size_t layerCnt = 1;
3663    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3664    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3665    bool optimize = false;
3666
3667    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3668            optimize));
3669}
3670
3671/* TESTCASE: Tests that the HWC2 can present 2 default layers. */
3672TEST_F(Hwc2Test, PRESENT_DISPLAY_default_2)
3673{
3674    const size_t layerCnt = 2;
3675    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3676    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3677    bool optimize = false;
3678
3679    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3680            optimize));
3681}
3682
3683/* TESTCASE: Tests that the HWC2 can present 3 default layers. */
3684TEST_F(Hwc2Test, PRESENT_DISPLAY_default_3)
3685{
3686    const size_t layerCnt = 3;
3687    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3688    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3689    bool optimize = false;
3690
3691    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3692            optimize));
3693}
3694
3695/* TESTCASE: Tests that the HWC2 can present 4 default layers. */
3696TEST_F(Hwc2Test, PRESENT_DISPLAY_default_4)
3697{
3698    const size_t layerCnt = 4;
3699    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3700    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3701    bool optimize = false;
3702
3703    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3704            optimize));
3705}
3706
3707/* TESTCASE: Tests that the HWC2 can present 5 default layers. */
3708TEST_F(Hwc2Test, PRESENT_DISPLAY_default_5)
3709{
3710    const size_t layerCnt = 5;
3711    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3712    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3713    bool optimize = false;
3714
3715    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3716            optimize));
3717}
3718
3719/* TESTCASE: Tests that the HWC2 can present 6 default layers. */
3720TEST_F(Hwc2Test, PRESENT_DISPLAY_default_6)
3721{
3722    const size_t layerCnt = 6;
3723    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3724    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
3725    bool optimize = false;
3726
3727    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3728            optimize));
3729}
3730
3731/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3732 * blend mode. */
3733TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_1)
3734{
3735    const size_t layerCnt = 1;
3736    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3737    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3738            {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete},
3739            {Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Basic},
3740            {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}};
3741    bool optimize = false;
3742
3743    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3744            optimize));
3745}
3746
3747/* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3748 * blend mode. */
3749TEST_F(Hwc2Test, PRESENT_DISPLAY_blend_mode_2)
3750{
3751    const size_t layerCnt = 2;
3752    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3753    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3754            {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Complete},
3755            {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic}};
3756    bool optimize = false;
3757
3758    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3759            optimize));
3760}
3761
3762/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3763 * buffer. */
3764TEST_F(Hwc2Test, PRESENT_DISPLAY_buffer_1)
3765{
3766    const size_t layerCnt = 1;
3767    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3768    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3769            {{Hwc2TestPropertyName::BufferArea, Hwc2TestCoverage::Complete}};
3770    bool optimize = true;
3771
3772    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3773            optimize));
3774}
3775
3776/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3777 * color. */
3778TEST_F(Hwc2Test, PRESENT_DISPLAY_color_1)
3779{
3780    const size_t layerCnt = 1;
3781    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3782    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3783            {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3784            {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Complete}};
3785    bool optimize = true;
3786
3787    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3788            optimize));
3789}
3790
3791/* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3792 * color. */
3793TEST_F(Hwc2Test, PRESENT_DISPLAY_color_2)
3794{
3795    const size_t layerCnt = 2;
3796    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3797    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3798            {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3799            {Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic},
3800            {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Basic},
3801            {Hwc2TestPropertyName::Color, Hwc2TestCoverage::Basic}};
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 1 layer with complete coverage of
3809 * composition. */
3810TEST_F(Hwc2Test, PRESENT_DISPLAY_composition_1)
3811{
3812    const size_t layerCnt = 1;
3813    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3814    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3815            {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete}};
3816    bool optimize = true;
3817
3818    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3819            optimize));
3820}
3821
3822/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3823 * cursor. */
3824TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_1)
3825{
3826    const size_t layerCnt = 1;
3827    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3828    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3829            {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3830            {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete}};
3831    bool optimize = true;
3832
3833    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3834            optimize));
3835}
3836
3837/* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3838 * cursor. */
3839TEST_F(Hwc2Test, PRESENT_DISPLAY_cursor_2)
3840{
3841    const size_t layerCnt = 2;
3842    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3843    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3844            {{Hwc2TestPropertyName::Composition, Hwc2TestCoverage::Complete},
3845            {Hwc2TestPropertyName::CursorPosition, Hwc2TestCoverage::Complete},
3846            {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}};
3847    bool optimize = true;
3848
3849    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3850            optimize));
3851}
3852
3853/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3854 * dataspace. */
3855TEST_F(Hwc2Test, PRESENT_DISPLAY_dataspace_1)
3856{
3857    const size_t layerCnt = 1;
3858    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3859    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3860            {{Hwc2TestPropertyName::Dataspace, Hwc2TestCoverage::Complete}};
3861    bool optimize = true;
3862
3863    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3864            optimize));
3865}
3866
3867/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3868 * display frame. */
3869TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_1)
3870{
3871    const size_t layerCnt = 1;
3872    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3873    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3874            {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3875    bool optimize = true;
3876
3877    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3878            optimize));
3879}
3880
3881/* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3882 * display frame. */
3883TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_2)
3884{
3885    const size_t layerCnt = 2;
3886    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3887    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3888            {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3889    bool optimize = true;
3890
3891    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3892            optimize));
3893}
3894
3895/* TESTCASE: Tests that the HWC2 can present 3 layers with complete coverage of
3896 * display frame. */
3897TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_3)
3898{
3899    const size_t layerCnt = 3;
3900    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3901    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3902            {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3903    bool optimize = true;
3904
3905    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3906            optimize));
3907}
3908
3909/* TESTCASE: Tests that the HWC2 can present 4 layers with complete coverage of
3910 * display frame. */
3911TEST_F(Hwc2Test, PRESENT_DISPLAY_display_frame_4)
3912{
3913    const size_t layerCnt = 4;
3914    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3915    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3916            {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete}};
3917    bool optimize = true;
3918
3919    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3920            optimize));
3921}
3922
3923/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3924 * plane alpha. */
3925TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_1)
3926{
3927    const size_t layerCnt = 1;
3928    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3929    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3930            {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic},
3931            {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}};
3932    bool optimize = false;
3933
3934    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3935            optimize));
3936}
3937
3938/* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3939 * plane alpha. */
3940TEST_F(Hwc2Test, PRESENT_DISPLAY_plane_alpha_2)
3941{
3942    const size_t layerCnt = 2;
3943    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3944    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3945            {{Hwc2TestPropertyName::BlendMode, Hwc2TestCoverage::Basic},
3946            {Hwc2TestPropertyName::PlaneAlpha, Hwc2TestCoverage::Complete}};
3947    bool optimize = false;
3948
3949    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3950            optimize));
3951}
3952
3953/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3954 * source crop. */
3955TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_1)
3956{
3957    const size_t layerCnt = 1;
3958    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3959    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3960            {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete},
3961            {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}};
3962    bool optimize = true;
3963
3964    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3965            optimize));
3966}
3967
3968/* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
3969 * source crop. */
3970TEST_F(Hwc2Test, PRESENT_DISPLAY_source_crop_2)
3971{
3972    const size_t layerCnt = 2;
3973    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3974    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3975            {{Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Complete},
3976            {Hwc2TestPropertyName::SourceCrop, Hwc2TestCoverage::Complete}};
3977    bool optimize = true;
3978
3979    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3980            optimize));
3981}
3982
3983
3984/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3985 * surface damage. */
3986TEST_F(Hwc2Test, PRESENT_DISPLAY_surface_damage_1)
3987{
3988    const size_t layerCnt = 1;
3989    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
3990    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
3991            {{Hwc2TestPropertyName::SurfaceDamage, Hwc2TestCoverage::Complete}};
3992    bool optimize = true;
3993
3994    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
3995            optimize));
3996}
3997
3998/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
3999 * transform. */
4000TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_1)
4001{
4002    const size_t layerCnt = 1;
4003    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
4004    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
4005            {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete}};
4006    bool optimize = true;
4007
4008    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
4009            optimize));
4010}
4011
4012/* TESTCASE: Tests that the HWC2 can present 2 layers with complete coverage of
4013 * transform. */
4014TEST_F(Hwc2Test, PRESENT_DISPLAY_transform_2)
4015{
4016    const size_t layerCnt = 2;
4017    Hwc2TestCoverage coverage = Hwc2TestCoverage::Default;
4018    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions =
4019            {{Hwc2TestPropertyName::Transform, Hwc2TestCoverage::Complete},
4020            {Hwc2TestPropertyName::DisplayFrame, Hwc2TestCoverage::Basic}};
4021    bool optimize = true;
4022
4023    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
4024            optimize));
4025}
4026
4027/* TESTCASE: Tests that the HWC2 can present 1 layer with complete coverage of
4028 * basic. */
4029TEST_F(Hwc2Test, PRESENT_DISPLAY_basic_1)
4030{
4031    const size_t layerCnt = 1;
4032    Hwc2TestCoverage coverage = Hwc2TestCoverage::Basic;
4033    std::unordered_map<Hwc2TestPropertyName, Hwc2TestCoverage> exceptions;
4034    bool optimize = true;
4035
4036    ASSERT_NO_FATAL_FAILURE(presentDisplays(layerCnt, coverage, exceptions,
4037            optimize));
4038}
4039
4040/* TESTCASE: Tests that the HWC2 cannot present a bad display.  */
4041TEST_F(Hwc2Test, PRESENT_DISPLAY_bad_display)
4042{
4043    hwc2_display_t display;
4044    int32_t presentFence;
4045    hwc2_error_t err = HWC2_ERROR_NONE;
4046
4047    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4048
4049    ASSERT_NO_FATAL_FAILURE(presentDisplay(display, &presentFence, &err));
4050    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4051}
4052
4053/* TESTCASE: Tests that the HWC2 cannot present an unvalidated display. */
4054TEST_F(Hwc2Test, PRESENT_DISPLAY_not_validated)
4055{
4056    ASSERT_NO_FATAL_FAILURE(displayLayers(Hwc2TestCoverage::Default, 1,
4057            [] (Hwc2Test* test, hwc2_display_t display,
4058                    const std::vector<hwc2_layer_t>& /*layers*/,
4059                    Hwc2TestLayers* /*testLayers*/) {
4060
4061                int32_t presentFence;
4062                hwc2_error_t err = HWC2_ERROR_NONE;
4063
4064                ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display,
4065                        HWC2_POWER_MODE_ON));
4066                ASSERT_NO_FATAL_FAILURE(test->enableVsync(display));
4067
4068                ASSERT_NO_FATAL_FAILURE(test->waitForVsync());
4069
4070                ASSERT_NO_FATAL_FAILURE(test->presentDisplay(display,
4071                        &presentFence, &err));
4072                EXPECT_EQ(err, HWC2_ERROR_NOT_VALIDATED)
4073                        << "returned wrong error code";
4074
4075                ASSERT_NO_FATAL_FAILURE(test->disableVsync(display));
4076                ASSERT_NO_FATAL_FAILURE(test->setPowerMode(display,
4077                        HWC2_POWER_MODE_OFF));
4078            }
4079    ));
4080}
4081
4082/* TESTCASE: Tests that the HWC2 cannot get release fences from a bad display. */
4083TEST_F(Hwc2Test, GET_RELEASE_FENCES_bad_display)
4084{
4085    hwc2_display_t display;
4086    std::vector<hwc2_layer_t> layers;
4087    std::vector<int32_t> fences;
4088    hwc2_error_t err = HWC2_ERROR_NONE;
4089
4090    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4091
4092    ASSERT_NO_FATAL_FAILURE(getReleaseFences(display, &layers, &fences, &err));
4093    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4094}
4095
4096static const std::array<android_color_mode, 9> androidColorModes = {{
4097    HAL_COLOR_MODE_NATIVE,
4098    HAL_COLOR_MODE_STANDARD_BT601_625,
4099    HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED,
4100    HAL_COLOR_MODE_STANDARD_BT601_525,
4101    HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED,
4102    HAL_COLOR_MODE_STANDARD_BT709,
4103    HAL_COLOR_MODE_DCI_P3,
4104    HAL_COLOR_MODE_SRGB,
4105    HAL_COLOR_MODE_ADOBE_RGB,
4106}};
4107
4108/* TESTCASE: Tests that the HWC2 can get the color modes for a display. The
4109 * display must support HAL_COLOR_MODE_NATIVE */
4110TEST_F(Hwc2Test, GET_COLOR_MODES)
4111{
4112    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4113            [] (Hwc2Test* test, hwc2_display_t display) {
4114
4115                std::vector<android_color_mode_t> colorModes;
4116
4117                ASSERT_NO_FATAL_FAILURE(test->getColorModes(display,
4118                        &colorModes));
4119
4120                EXPECT_NE(std::count(colorModes.begin(), colorModes.end(),
4121                        HAL_COLOR_MODE_NATIVE), 0) << "all displays"
4122                        " must support HAL_COLOR_MODE_NATIVE";
4123            }
4124    ));
4125}
4126
4127/* TESTCASE: Tests that the HWC2 cannot get color modes from a bad display. */
4128TEST_F(Hwc2Test, GET_COLOR_MODES_bad_display)
4129{
4130    hwc2_display_t display;
4131    std::vector<android_color_mode_t> colorModes;
4132    hwc2_error_t err = HWC2_ERROR_NONE;
4133
4134    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4135
4136    ASSERT_NO_FATAL_FAILURE(getColorModes(display, &colorModes, &err));
4137    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4138}
4139
4140/* TESTCASE: Tests that the HWC2 can set the required color mode on a display. */
4141TEST_F(Hwc2Test, SET_COLOR_MODES)
4142{
4143    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4144            [] (Hwc2Test* test, hwc2_display_t display) {
4145
4146                const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE;
4147
4148                EXPECT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode));
4149            }
4150    ));
4151}
4152
4153/* TESTCASE: Tests that the HWC2 cannot set a color mode on a bad display. */
4154TEST_F(Hwc2Test, SET_COLOR_MODES_bad_display)
4155{
4156    hwc2_display_t display;
4157    const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE;
4158    hwc2_error_t err = HWC2_ERROR_NONE;
4159
4160    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4161
4162    ASSERT_NO_FATAL_FAILURE(setColorMode(display, colorMode, &err));
4163    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4164}
4165
4166/* TESTCASE: Tests that the HWC2 cannot set an invalid color mode. */
4167TEST_F(Hwc2Test, SET_COLOR_MODES_bad_parameter)
4168{
4169    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4170            [] (Hwc2Test* test, hwc2_display_t display) {
4171
4172                const android_color_mode_t colorMode =
4173                        static_cast<android_color_mode_t>(-1);
4174                hwc2_error_t err = HWC2_ERROR_NONE;
4175
4176                ASSERT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode,
4177                        &err));
4178                EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER)
4179                        << "returned wrong error code";
4180            }
4181    ));
4182}
4183
4184/* TESTCASE: Tests that the HWC2 either supports or returns error unsupported
4185 * for all valid color modes. */
4186TEST_F(Hwc2Test, SET_COLOR_MODES_unsupported)
4187{
4188    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4189            [] (Hwc2Test* test, hwc2_display_t display) {
4190
4191                for (auto colorMode : androidColorModes) {
4192                    hwc2_error_t err = HWC2_ERROR_NONE;
4193
4194                    ASSERT_NO_FATAL_FAILURE(test->setColorMode(display,
4195                            colorMode, &err));
4196
4197                    EXPECT_TRUE(err == HWC2_ERROR_NONE
4198                            || err == HWC2_ERROR_UNSUPPORTED)
4199                            << "returned wrong error code";
4200                }
4201            }
4202    ));
4203}
4204
4205/* TESTCASE: Tests that the HWC2 gets the HDR capabilities for a display and
4206 * test if they are valid. */
4207TEST_F(Hwc2Test, GET_HDR_CAPABILITIES)
4208{
4209    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4210            [] (Hwc2Test* test, hwc2_display_t display) {
4211
4212                std::vector<android_hdr_t> hdrCapabilities;
4213                float maxLuminance, maxAverageLuminance, minLuminance;
4214
4215                EXPECT_NO_FATAL_FAILURE(test->getHdrCapabilities(display,
4216                        &hdrCapabilities, &maxLuminance, &maxAverageLuminance,
4217                        &minLuminance));
4218
4219                if (hdrCapabilities.empty())
4220                    return;
4221
4222                EXPECT_GE(maxLuminance, maxAverageLuminance);
4223                EXPECT_GE(maxAverageLuminance, minLuminance);
4224            }
4225    ));
4226}
4227
4228/* TESTCASE: Tests that the HWC2 cannot get hdr capabilities from a bad display */
4229TEST_F(Hwc2Test, GET_HDR_CAPABILITIES_bad_display)
4230{
4231    hwc2_display_t display;
4232    std::vector<android_hdr_t> hdrCapabilities;
4233    float maxLuminance, maxAverageLuminance, minLuminance;
4234    hwc2_error_t err = HWC2_ERROR_NONE;
4235
4236    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4237
4238    ASSERT_NO_FATAL_FAILURE(getHdrCapabilities(display, &hdrCapabilities,
4239            &maxLuminance, &maxAverageLuminance, &minLuminance, &err));
4240    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4241}
4242
4243static const std::array<float, 16> identityMatrix = {{
4244    1.0,  0.0,  0.0,  0.0,
4245    0.0,  1.0,  0.0,  0.0,
4246    0.0,  0.0,  1.0,  0.0,
4247    0.0,  0.0,  0.0,  1.0,
4248}};
4249
4250/* Values for the color transform matrices were precomputed using the source code
4251 * in surfaceflinger/Effects/Daltonizer.cpp. */
4252
4253static const std::array<const std::array<float, 16>, 5> exampleMatrices = {{
4254    identityMatrix,
4255    /* Converts RGB color to the XYZ space */
4256    {{ 0.4124, 0.2126, 0.0193, 0,
4257       0.3576, 0.7152, 0.1192, 0,
4258       0.1805, 0.0722, 0.9505, 0,
4259       0     , 0     , 0     , 1 }},
4260    /* Protanomaly */
4261    {{ 0.068493,  0.931506,  0,  0,
4262       0.068493,  0.931507,  0,  0,
4263       0.013626, -0.013626,  1,  0,
4264       0,         0,         0,  1 }},
4265    /* Deuteranomaly */
4266    {{ 0.288299, 0.711701,  0,  0,
4267       0.052709, 0.947291,  0,  0,
4268      -0.257912, 0.257912,  1,  0,
4269       0,        0,         0,  1 }},
4270    /* Tritanomaly */
4271    {{ 1, -0.805712, 0.805712,  0,
4272       0,  0.378838, 0.621162,  0,
4273       0,  0.104823, 0.895177,  0,
4274       0,  0,        0,         1 }},
4275}};
4276
4277/* TESTCASE: Tests that the HWC2 can set the identity color transform */
4278TEST_F(Hwc2Test, SET_COLOR_TRANSFORM)
4279{
4280    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4281            [] (Hwc2Test* test, hwc2_display_t display) {
4282
4283                EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display,
4284                        identityMatrix, HAL_COLOR_TRANSFORM_IDENTITY));
4285            }
4286    ));
4287}
4288
4289/* TESTCASE: Tests that the HWC2 cannot set the color transform for a bad
4290 * display. */
4291TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_display)
4292{
4293    hwc2_display_t display;
4294    hwc2_error_t err = HWC2_ERROR_NONE;
4295
4296    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4297
4298    ASSERT_NO_FATAL_FAILURE(setColorTransform(display, identityMatrix,
4299            HAL_COLOR_TRANSFORM_IDENTITY, &err));
4300    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4301}
4302
4303/* TESTCASE: Tests that the HWC2 cannot set an invalid color transform. */
4304TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_bad_parameter)
4305{
4306    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4307            [] (Hwc2Test* test, hwc2_display_t display) {
4308
4309                const android_color_transform_t hint =
4310                        static_cast<android_color_transform_t>(-1);
4311                hwc2_error_t err = HWC2_ERROR_NONE;
4312
4313                ASSERT_NO_FATAL_FAILURE(test->setColorTransform(display,
4314                        identityMatrix, hint, &err));
4315                EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER)
4316                        << "returned wrong error code";
4317            }
4318    ));
4319}
4320
4321/* TESTCASE: Tests that the HWC2 can set an arbitrary color matrix. */
4322TEST_F(Hwc2Test, SET_COLOR_TRANSFORM_arbitrary_matrix)
4323{
4324    ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
4325            [] (Hwc2Test* test, hwc2_display_t display) {
4326
4327                const android_color_transform_t hint =
4328                        HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX;
4329
4330                for (const std::array<float, 16>& matrix : exampleMatrices) {
4331                    EXPECT_NO_FATAL_FAILURE(test->setColorTransform(display,
4332                            matrix, hint));
4333                }
4334            }
4335    ));
4336}
4337
4338/* TESTCASE: Tests that the HWC2 create an destory virtual displays. */
4339TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY)
4340{
4341    ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete,
4342            [] (Hwc2Test* /*test*/, hwc2_display_t /*display*/,
4343                    Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) { }));
4344}
4345
4346/* TESTCASE: Tests that the HWC2 can create and destroy multiple virtual
4347 * displays. */
4348TEST_F(Hwc2Test, CREATE_DESTROY_VIRTUAL_DISPLAY_multiple)
4349{
4350    Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete);
4351    std::vector<hwc2_display_t> displays;
4352
4353    do {
4354        const UnsignedArea& dimension =
4355                testVirtualDisplay.getDisplayDimension();
4356        android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888;
4357        hwc2_display_t display;
4358        hwc2_error_t err = HWC2_ERROR_NONE;
4359
4360        ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(dimension.width,
4361                dimension.height, &desiredFormat, &display, &err));
4362
4363        EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_NO_RESOURCES
4364                || err == HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
4365        EXPECT_GE(desiredFormat, 0) << "invalid format";
4366
4367        if (err == HWC2_ERROR_NONE)
4368            displays.push_back(display);
4369
4370    } while (testVirtualDisplay.advance());
4371
4372    for (hwc2_display_t display : displays) {
4373        EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display));
4374    }
4375}
4376
4377/* TESTCASE: Tests that the HWC2 cannot destroy a bad virtual displays.  */
4378TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_display)
4379{
4380    hwc2_display_t display;
4381    hwc2_error_t err = HWC2_ERROR_NONE;
4382
4383    ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
4384
4385    ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err));
4386    EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
4387}
4388
4389/* TESTCASE: Tests that the HWC2 cannot destroy a physical display. */
4390TEST_F(Hwc2Test, DESTROY_VIRTUAL_DISPLAY_bad_parameter)
4391{
4392    hwc2_display_t display = HWC_DISPLAY_PRIMARY;
4393    hwc2_error_t err = HWC2_ERROR_NONE;
4394
4395    ASSERT_NO_FATAL_FAILURE(destroyVirtualDisplay(display, &err));
4396    EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER) << "returned wrong error code";
4397}
4398
4399/* TESTCASE: Tests that the HWC2 can get the max virtual display count. */
4400TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT)
4401{
4402    uint32_t maxCnt;
4403
4404    ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt));
4405}
4406
4407/* TESTCASE: Tests that the HWC2 returns the same max virtual display count for
4408 * each call. */
4409TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_duplicate)
4410{
4411    uint32_t maxCnt1, maxCnt2;
4412
4413    ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt1));
4414    ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt2));
4415
4416    EXPECT_EQ(maxCnt1, maxCnt2) << "returned two different max virtual display"
4417            " counts";
4418}
4419
4420/* TESTCASE: Tests that the HWC2 can create the max number of virtual displays
4421 * that it reports. */
4422TEST_F(Hwc2Test, GET_MAX_VIRTUAL_DISPLAY_COUNT_create_max)
4423{
4424    std::vector<hwc2_display_t> displays;
4425    uint32_t maxCnt;
4426
4427    ASSERT_NO_FATAL_FAILURE(getMaxVirtualDisplayCount(&maxCnt));
4428
4429    while (displays.size() < maxCnt) {
4430        uint32_t width = 1920, height = 1080;
4431        android_pixel_format_t desiredFormat = HAL_PIXEL_FORMAT_RGBA_8888;
4432        hwc2_display_t display;
4433        hwc2_error_t err = HWC2_ERROR_NONE;
4434
4435        ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(width, height,
4436                    &desiredFormat, &display, &err));
4437
4438        EXPECT_TRUE(err == HWC2_ERROR_NONE || err == HWC2_ERROR_UNSUPPORTED)
4439                << "returned wrong error code";
4440        if (err != HWC2_ERROR_NONE)
4441            break;
4442
4443        displays.push_back(display);
4444    }
4445
4446    for (hwc2_display_t display : displays) {
4447        EXPECT_NO_FATAL_FAILURE(destroyVirtualDisplay(display));
4448    }
4449}
4450
4451/* TESTCASE: Tests that the HWC2 can set an output buffer for a virtual
4452 * display. */
4453TEST_F(Hwc2Test, SET_OUTPUT_BUFFER)
4454{
4455    ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Complete,
4456            [] (Hwc2Test* test, hwc2_display_t display,
4457                    Hwc2TestVirtualDisplay* testVirtualDisplay) {
4458
4459                buffer_handle_t handle;
4460                android::base::unique_fd acquireFence;
4461
4462                if (testVirtualDisplay->getBuffer(&handle, &acquireFence) >= 0)
4463                    EXPECT_NO_FATAL_FAILURE(test->setOutputBuffer(display,
4464                            handle, acquireFence));
4465            }));
4466}
4467
4468/* TESTCASE: Tests that the HWC2 cannot set an output buffer for a bad display */
4469TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_display)
4470{
4471    ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default,
4472            [] (Hwc2Test* test, hwc2_display_t /*display*/,
4473                    Hwc2TestVirtualDisplay* testVirtualDisplay) {
4474
4475                hwc2_display_t badDisplay;
4476                buffer_handle_t handle;
4477                android::base::unique_fd acquireFence;
4478                hwc2_error_t err = HWC2_ERROR_NONE;
4479
4480                ASSERT_NO_FATAL_FAILURE(test->getBadDisplay(&badDisplay));
4481
4482                if (testVirtualDisplay->getBuffer(&handle, &acquireFence) < 0)
4483                    return;
4484
4485                ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(badDisplay,
4486                        handle, acquireFence, &err));
4487                EXPECT_TRUE(err == HWC2_ERROR_BAD_DISPLAY)
4488                        << "returned wrong error code";
4489            }));
4490}
4491
4492/* TESTCASE: Tests that the HWC2 cannot set an invalid output buffer. */
4493TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_bad_parameter)
4494{
4495    ASSERT_NO_FATAL_FAILURE(createVirtualDisplay(Hwc2TestCoverage::Default,
4496            [] (Hwc2Test* test, hwc2_display_t display,
4497                    Hwc2TestVirtualDisplay* /*testVirtualDisplay*/) {
4498
4499                const buffer_handle_t handle = nullptr;
4500                uint32_t releaseFence = -1;
4501                hwc2_error_t err = HWC2_ERROR_NONE;
4502
4503                ASSERT_NO_FATAL_FAILURE(test->setOutputBuffer(display, handle,
4504                        releaseFence, &err));
4505                EXPECT_EQ(err, HWC2_ERROR_BAD_PARAMETER)
4506                        << "returned wrong error code";
4507            }));
4508}
4509
4510/* TESTCASE: Tests that the HWC2 cannot set an output buffer for non virtual
4511 * display */
4512TEST_F(Hwc2Test, SET_OUTPUT_BUFFER_unsupported)
4513{
4514    for (auto display : mDisplays) {
4515        Hwc2TestVirtualDisplay testVirtualDisplay(Hwc2TestCoverage::Complete);
4516
4517        do {
4518            buffer_handle_t handle;
4519            android::base::unique_fd acquireFence;
4520            hwc2_error_t err = HWC2_ERROR_NONE;
4521
4522            if (testVirtualDisplay.getBuffer(&handle, &acquireFence) < 0)
4523                continue;
4524
4525            ASSERT_NO_FATAL_FAILURE(setOutputBuffer(display, handle,
4526                    acquireFence, &err));
4527            EXPECT_EQ(err, HWC2_ERROR_UNSUPPORTED) << "returned wrong error code";
4528
4529        } while (testVirtualDisplay.advance());
4530    }
4531}
4532