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 #define LOG_TAG "graphics_composer_hidl_hal_test"
18 
19 #include <android-base/logging.h>
20 #include <composer-vts/2.1/ComposerVts.h>
21 #include <composer-vts/2.1/GraphicsComposerCallback.h>
22 #include <composer-vts/2.1/TestCommandReader.h>
23 #include <mapper-vts/2.0/MapperVts.h>
24 #include <mapper-vts/3.0/MapperVts.h>
25 
26 #include <VtsHalHidlTargetTestBase.h>
27 #include <VtsHalHidlTargetTestEnvBase.h>
28 #include <unistd.h>
29 
30 #include <algorithm>
31 #include <array>
32 #include <memory>
33 #include <mutex>
34 #include <unordered_set>
35 #include <vector>
36 
37 namespace android {
38 namespace hardware {
39 namespace graphics {
40 namespace composer {
41 namespace V2_1 {
42 namespace vts {
43 namespace {
44 
45 using android::hardware::graphics::common::V1_0::BufferUsage;
46 using android::hardware::graphics::common::V1_0::ColorMode;
47 using android::hardware::graphics::common::V1_0::ColorTransform;
48 using android::hardware::graphics::common::V1_0::Dataspace;
49 using android::hardware::graphics::common::V1_0::PixelFormat;
50 using android::hardware::graphics::common::V1_0::Transform;
51 using GrallocError = android::hardware::graphics::mapper::V2_0::Error;
52 
53 // Test environment for graphics.composer
54 class GraphicsComposerHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
55    public:
56     // get the test environment singleton
Instance()57     static GraphicsComposerHidlEnvironment* Instance() {
58         static GraphicsComposerHidlEnvironment* instance = new GraphicsComposerHidlEnvironment;
59         return instance;
60     }
61 
registerTestServices()62     virtual void registerTestServices() override { registerTestService<IComposer>(); }
63 
64    private:
GraphicsComposerHidlEnvironment()65     GraphicsComposerHidlEnvironment() {}
66 
67     GTEST_DISALLOW_COPY_AND_ASSIGN_(GraphicsComposerHidlEnvironment);
68 };
69 
70 class GraphicsComposerHidlTest : public ::testing::VtsHalHidlTargetTestBase {
71    protected:
SetUp()72     void SetUp() override {
73         VtsHalHidlTargetTestBase::SetUp();
74         ASSERT_NO_FATAL_FAILURE(
75             mComposer = std::make_unique<Composer>(
76                 GraphicsComposerHidlEnvironment::Instance()->getServiceName<IComposer>()));
77         ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient());
78 
79         mComposerCallback = new GraphicsComposerCallback;
80         mComposerClient->registerCallback(mComposerCallback);
81 
82         // assume the first display is primary and is never removed
83         mPrimaryDisplay = waitForFirstDisplay();
84 
85         // explicitly disable vsync
86         mComposerClient->setVsyncEnabled(mPrimaryDisplay, false);
87         mComposerCallback->setVsyncAllowed(false);
88 
89         mInvalidDisplayId = GetInvalidDisplayId();
90 
91         // Although 0 could be an invalid display, a return value of 0
92         // from GetInvalidDisplayId means all other ids are in use, a condition which
93         // we are assuming a device will never have
94         ASSERT_NE(0, mInvalidDisplayId);
95     }
96 
TearDown()97     void TearDown() override {
98         if (mComposerCallback != nullptr) {
99             EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
100             EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
101             EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
102         }
103         VtsHalHidlTargetTestBase::TearDown();
104     }
105 
106     // returns an invalid display id (one that has not been registered to a
107     // display.  Currently assuming that a device will never have close to
108     // std::numeric_limit<uint64_t>::max() displays registered while running tests
GetInvalidDisplayId()109     Display GetInvalidDisplayId() {
110         std::vector<Display> validDisplays = mComposerCallback->getDisplays();
111 
112         uint64_t id = std::numeric_limits<uint64_t>::max();
113         while (id > 0) {
114             if (std::find(validDisplays.begin(), validDisplays.end(), id) == validDisplays.end()) {
115                 return id;
116             }
117             id--;
118         }
119 
120         return 0;
121     }
122 
123     // use the slot count usually set by SF
124     static constexpr uint32_t kBufferSlotCount = 64;
125 
126     std::unique_ptr<Composer> mComposer;
127     std::unique_ptr<ComposerClient> mComposerClient;
128     sp<GraphicsComposerCallback> mComposerCallback;
129     // the first display and is assumed never to be removed
130     Display mPrimaryDisplay;
131     Display mInvalidDisplayId;
132 
133    private:
waitForFirstDisplay()134     Display waitForFirstDisplay() {
135         while (true) {
136             std::vector<Display> displays = mComposerCallback->getDisplays();
137             if (displays.empty()) {
138                 usleep(5 * 1000);
139                 continue;
140             }
141 
142             return displays[0];
143         }
144     }
145 };
146 
147 /**
148  * Test IComposer::getCapabilities.
149  *
150  * Test that IComposer::getCapabilities returns no invalid capabilities.
151  */
TEST_F(GraphicsComposerHidlTest,GetCapabilities)152 TEST_F(GraphicsComposerHidlTest, GetCapabilities) {
153     auto capabilities = mComposer->getCapabilities();
154     ASSERT_EQ(capabilities.end(),
155               std::find(capabilities.begin(), capabilities.end(), IComposer::Capability::INVALID));
156 }
157 
158 /**
159  * Test IComposer::dumpDebugInfo.
160  */
TEST_F(GraphicsComposerHidlTest,DumpDebugInfo)161 TEST_F(GraphicsComposerHidlTest, DumpDebugInfo) {
162     mComposer->dumpDebugInfo();
163 }
164 
165 /**
166  * Test IComposer::createClient.
167  *
168  * Test that IComposerClient is a singleton.
169  */
TEST_F(GraphicsComposerHidlTest,CreateClientSingleton)170 TEST_F(GraphicsComposerHidlTest, CreateClientSingleton) {
171     mComposer->getRaw()->createClient(
172         [&](const auto& tmpError, const auto&) { EXPECT_EQ(Error::NO_RESOURCES, tmpError); });
173 }
174 
175 /**
176  * Test IComposerClient::createVirtualDisplay and
177  * IComposerClient::destroyVirtualDisplay.
178  *
179  * Test that virtual displays can be created and has the correct display type.
180  */
TEST_F(GraphicsComposerHidlTest,CreateVirtualDisplay)181 TEST_F(GraphicsComposerHidlTest, CreateVirtualDisplay) {
182     if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
183         GTEST_SUCCEED() << "no virtual display support";
184         return;
185     }
186 
187     Display display;
188     PixelFormat format;
189     ASSERT_NO_FATAL_FAILURE(
190         display = mComposerClient->createVirtualDisplay(64, 64, PixelFormat::IMPLEMENTATION_DEFINED,
191                                                         kBufferSlotCount, &format));
192 
193     // test display type
194     IComposerClient::DisplayType type = mComposerClient->getDisplayType(display);
195     EXPECT_EQ(IComposerClient::DisplayType::VIRTUAL, type);
196 
197     mComposerClient->destroyVirtualDisplay(display);
198 }
199 
200 /**
201  * Test IComposerClient::destroyVirtualDisplay
202  *
203  * Test that passing a bad display handle to destroyVirtualDisplay
204  * returns a BAD_DISPLAY error
205  */
TEST_F(GraphicsComposerHidlTest,DestroyVirtualDisplayBadDisplay)206 TEST_F(GraphicsComposerHidlTest, DestroyVirtualDisplayBadDisplay) {
207     if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
208         GTEST_SUCCEED() << "no virtual display support";
209         return;
210     }
211 
212     Error error = mComposerClient->getRaw()->destroyVirtualDisplay(mInvalidDisplayId);
213     ASSERT_EQ(Error::BAD_DISPLAY, error);
214 }
215 
216 /**
217  * Test IComposerClient::createLayer and IComposerClient::destroyLayer.
218  *
219  * Test that layers can be created and destroyed.
220  */
TEST_F(GraphicsComposerHidlTest,CreateLayer)221 TEST_F(GraphicsComposerHidlTest, CreateLayer) {
222     Layer layer;
223     ASSERT_NO_FATAL_FAILURE(layer =
224                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
225 
226     mComposerClient->destroyLayer(mPrimaryDisplay, layer);
227 }
228 
229 /**
230  * Test IComposerClient::createLayer
231  *
232  * Test that passing in an invalid display handle to createLayer returns
233  * BAD_DISPLAY.
234  */
TEST_F(GraphicsComposerHidlTest,CreateLayerBadDisplay)235 TEST_F(GraphicsComposerHidlTest, CreateLayerBadDisplay) {
236     Error error;
237     mComposerClient->getRaw()->createLayer(
238         mInvalidDisplayId, kBufferSlotCount,
239         [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
240     ASSERT_EQ(Error::BAD_DISPLAY, error);
241 }
242 
243 /**
244  * Test IComposerClient::destroyLayer
245  *
246  * Test that passing in an invalid display handle to destroyLayer returns
247  * BAD_DISPLAY
248  */
TEST_F(GraphicsComposerHidlTest,DestroyLayerBadDisplay)249 TEST_F(GraphicsComposerHidlTest, DestroyLayerBadDisplay) {
250     Error error;
251     Layer layer;
252     ASSERT_NO_FATAL_FAILURE(layer =
253                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
254 
255     error = mComposerClient->getRaw()->destroyLayer(mInvalidDisplayId, layer);
256 
257     EXPECT_EQ(Error::BAD_DISPLAY, error);
258 
259     ASSERT_NO_FATAL_FAILURE(mComposerClient->destroyLayer(mPrimaryDisplay, layer));
260 }
261 
262 /**
263  * Test IComposerClient::destroyLayer
264  *
265  * Test that passing in an invalid layer handle to destroyLayer returns
266  * BAD_LAYER
267  */
TEST_F(GraphicsComposerHidlTest,DestroyLayerBadLayerError)268 TEST_F(GraphicsComposerHidlTest, DestroyLayerBadLayerError) {
269     // We haven't created any layers yet, so any id should be invalid
270     Error error = mComposerClient->getRaw()->destroyLayer(mPrimaryDisplay, 1);
271 
272     EXPECT_EQ(Error::BAD_LAYER, error);
273 }
274 
275 /**
276  * Test IComposerClient::getActiveConfig
277  *
278  * Test that passing in a bad display handle to getActiveConfig generates a
279  * BAD_DISPLAY error
280  */
TEST_F(GraphicsComposerHidlTest,GetActiveConfigBadDisplay)281 TEST_F(GraphicsComposerHidlTest, GetActiveConfigBadDisplay) {
282     Error error;
283     mComposerClient->getRaw()->getActiveConfig(
284         mInvalidDisplayId, [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
285     ASSERT_EQ(Error::BAD_DISPLAY, error);
286 }
287 
288 /**
289  * Test IComposerClient::getDisplayConfigs
290  *
291  * Test IComposerClient::getDisplayConfigs returns no error
292  * when passed in a valid display
293  */
TEST_F(GraphicsComposerHidlTest,GetDisplayConfig)294 TEST_F(GraphicsComposerHidlTest, GetDisplayConfig) {
295     std::vector<Config> configs;
296     ASSERT_NO_FATAL_FAILURE(configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay));
297 }
298 
299 /**
300  * Test IComposerClient::getDisplayConfigs
301  *
302  * Test IComposerClient::getDisplayConfigs returns BAD_DISPLAY
303  * when passed in an invalid display handle
304  */
TEST_F(GraphicsComposerHidlTest,GetDisplayConfigBadDisplay)305 TEST_F(GraphicsComposerHidlTest, GetDisplayConfigBadDisplay) {
306     Error error;
307     mComposerClient->getRaw()->getDisplayConfigs(
308         mInvalidDisplayId, [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
309     ASSERT_EQ(Error::BAD_DISPLAY, error);
310 }
311 
312 /**
313  * Test IComposerClient::getDisplayName.
314  */
TEST_F(GraphicsComposerHidlTest,GetDisplayName)315 TEST_F(GraphicsComposerHidlTest, GetDisplayName) {
316     mComposerClient->getDisplayName(mPrimaryDisplay);
317 }
318 
319 /**
320  * Test IComposerClient::getDisplayType.
321  *
322  * Test that IComposerClient::getDisplayType returns the correct display type
323  * for the primary display.
324  */
TEST_F(GraphicsComposerHidlTest,GetDisplayType)325 TEST_F(GraphicsComposerHidlTest, GetDisplayType) {
326     ASSERT_EQ(IComposerClient::DisplayType::PHYSICAL,
327               mComposerClient->getDisplayType(mPrimaryDisplay));
328 }
329 
330 /**
331  * Test IComposerClient::getClientTargetSupport.
332  *
333  * Test that IComposerClient::getClientTargetSupport returns true for the
334  * required client targets.
335  */
TEST_F(GraphicsComposerHidlTest,GetClientTargetSupport)336 TEST_F(GraphicsComposerHidlTest, GetClientTargetSupport) {
337     std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
338     for (auto config : configs) {
339         int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
340                                                              IComposerClient::Attribute::WIDTH);
341         int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
342                                                               IComposerClient::Attribute::HEIGHT);
343         ASSERT_LT(0, width);
344         ASSERT_LT(0, height);
345 
346         mComposerClient->setActiveConfig(mPrimaryDisplay, config);
347 
348         ASSERT_TRUE(mComposerClient->getClientTargetSupport(
349             mPrimaryDisplay, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN));
350     }
351 }
352 
353 /**
354  * Test IComposerClient::getClientTargetSupport
355  *
356  * Test that IComposerClient::getClientTargetSupport returns BAD_DISPLAY when
357  * passed an invalid display handle
358  */
TEST_F(GraphicsComposerHidlTest,GetClientTargetSupportBadDisplay)359 TEST_F(GraphicsComposerHidlTest, GetClientTargetSupportBadDisplay) {
360     std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
361     for (auto config : configs) {
362         int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
363                                                              IComposerClient::Attribute::WIDTH);
364         int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
365                                                               IComposerClient::Attribute::HEIGHT);
366         ASSERT_LT(0, width);
367         ASSERT_LT(0, height);
368 
369         mComposerClient->setActiveConfig(mPrimaryDisplay, config);
370 
371         Error error = mComposerClient->getRaw()->getClientTargetSupport(
372             mInvalidDisplayId, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN);
373         EXPECT_EQ(Error::BAD_DISPLAY, error);
374     }
375 }
376 
377 /**
378  * Test IComposerClient::getDisplayAttribute.
379  *
380  * Test that IComposerClient::getDisplayAttribute succeeds for the required
381  * formats, and succeeds or fails correctly for optional attributes.
382  */
TEST_F(GraphicsComposerHidlTest,GetDisplayAttribute)383 TEST_F(GraphicsComposerHidlTest, GetDisplayAttribute) {
384     std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
385     for (auto config : configs) {
386         const std::array<IComposerClient::Attribute, 3> requiredAttributes = {{
387             IComposerClient::Attribute::WIDTH, IComposerClient::Attribute::HEIGHT,
388             IComposerClient::Attribute::VSYNC_PERIOD,
389         }};
390         for (auto attribute : requiredAttributes) {
391             mComposerClient->getDisplayAttribute(mPrimaryDisplay, config, attribute);
392         }
393 
394         const std::array<IComposerClient::Attribute, 2> optionalAttributes = {{
395             IComposerClient::Attribute::DPI_X, IComposerClient::Attribute::DPI_Y,
396         }};
397         for (auto attribute : optionalAttributes) {
398             mComposerClient->getRaw()->getDisplayAttribute(
399                 mPrimaryDisplay, config, attribute, [&](const auto& tmpError, const auto&) {
400                     EXPECT_TRUE(tmpError == Error::NONE || tmpError == Error::UNSUPPORTED);
401                 });
402         }
403     }
404 }
405 
406 /**
407  * Test IComposerClient::getHdrCapabilities.
408  */
TEST_F(GraphicsComposerHidlTest,GetHdrCapabilities)409 TEST_F(GraphicsComposerHidlTest, GetHdrCapabilities) {
410     float maxLuminance;
411     float maxAverageLuminance;
412     float minLuminance;
413     mComposerClient->getHdrCapabilities(mPrimaryDisplay, &maxLuminance, &maxAverageLuminance,
414                                         &minLuminance);
415 }
416 
417 /**
418  * Test IComposerClient::setClientTargetSlotCount.
419  */
TEST_F(GraphicsComposerHidlTest,SetClientTargetSlotCount)420 TEST_F(GraphicsComposerHidlTest, SetClientTargetSlotCount) {
421     mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount);
422 }
423 
424 /**
425  * Test IComposerClient::setActiveConfig.
426  *
427  * Test that IComposerClient::setActiveConfig succeeds for all display
428  * configs.
429  */
TEST_F(GraphicsComposerHidlTest,SetActiveConfig)430 TEST_F(GraphicsComposerHidlTest, SetActiveConfig) {
431     std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
432     for (auto config : configs) {
433         mComposerClient->setActiveConfig(mPrimaryDisplay, config);
434         ASSERT_EQ(config, mComposerClient->getActiveConfig(mPrimaryDisplay));
435     }
436 }
437 
438 /**
439  * Test IComposerClient::setActiveConfig
440  *
441  * Test that config set during IComposerClient::setActiveConfig is maintained
442  * during a display on/off power cycle
443  */
TEST_F(GraphicsComposerHidlTest,SetActiveConfigPowerCycle)444 TEST_F(GraphicsComposerHidlTest, SetActiveConfigPowerCycle) {
445     ASSERT_NO_FATAL_FAILURE(
446         mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::OFF));
447     ASSERT_NO_FATAL_FAILURE(
448         mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::ON));
449 
450     std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
451     for (auto config : configs) {
452         mComposerClient->setActiveConfig(mPrimaryDisplay, config);
453         ASSERT_EQ(config, mComposerClient->getActiveConfig(mPrimaryDisplay));
454 
455         ASSERT_NO_FATAL_FAILURE(
456             mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::OFF));
457         ASSERT_NO_FATAL_FAILURE(
458             mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::ON));
459         ASSERT_EQ(config, mComposerClient->getActiveConfig(mPrimaryDisplay));
460     }
461 }
462 
463 /**
464  * Test IComposerClient::getColorMode
465  *
466  * Test that IComposerClient::getColorMode always returns ColorMode::NATIVE
467  */
TEST_F(GraphicsComposerHidlTest,GetColorModes)468 TEST_F(GraphicsComposerHidlTest, GetColorModes) {
469     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
470     auto nativeModeLocation = std::find(modes.begin(), modes.end(), ColorMode::NATIVE);
471 
472     ASSERT_NE(modes.end(), nativeModeLocation);
473 }
474 
475 /**
476  * Test IComposerClient::setColorMode.
477  *
478  * Test that IComposerClient::setColorMode succeeds for all color modes.
479  */
TEST_F(GraphicsComposerHidlTest,SetColorMode)480 TEST_F(GraphicsComposerHidlTest, SetColorMode) {
481     std::unordered_set<ColorMode> validModes;
482     for (auto mode : hidl_enum_range<ColorMode>()) {
483         validModes.insert(mode);
484     }
485 
486     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
487     for (auto mode : modes) {
488         if (validModes.count(mode)) {
489             mComposerClient->setColorMode(mPrimaryDisplay, mode);
490         }
491     }
492 }
493 
494 /**
495  * Test IComposerClient::setColorMode
496  *
497  * Test that IComposerClient::setColorMode returns BAD_DISPLAY for
498  * an invalid display handle
499  */
TEST_F(GraphicsComposerHidlTest,SetColorModeBadDisplay)500 TEST_F(GraphicsComposerHidlTest, SetColorModeBadDisplay) {
501     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
502     for (auto mode : modes) {
503         Error error = mComposerClient->getRaw()->setColorMode(mInvalidDisplayId, mode);
504         EXPECT_EQ(Error::BAD_DISPLAY, error);
505     }
506 }
507 
508 /**
509  * Test IComposerClient::setColorMode
510  *
511  * Test that IComposerClient::setColorMode returns BAD_PARAMETER when passed in
512  * an invalid color mode
513  */
TEST_F(GraphicsComposerHidlTest,SetColorModeBadParameter)514 TEST_F(GraphicsComposerHidlTest, SetColorModeBadParameter) {
515     Error error =
516         mComposerClient->getRaw()->setColorMode(mPrimaryDisplay, static_cast<ColorMode>(-1));
517     ASSERT_EQ(Error::BAD_PARAMETER, error);
518 }
519 
520 /**
521  * Test IComposerClient::getDozeSupport
522  *
523  * Test that IComposerClient::getDozeSupport returns
524  * BAD_DISPLAY when passed an invalid display handle
525  */
TEST_F(GraphicsComposerHidlTest,GetDozeSupportBadDisplay)526 TEST_F(GraphicsComposerHidlTest, GetDozeSupportBadDisplay) {
527     Error error;
528     mComposerClient->getRaw()->getDozeSupport(
529         mInvalidDisplayId, [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
530     ASSERT_EQ(Error::BAD_DISPLAY, error);
531 }
532 
533 /**
534  * Test IComposerClient::setPowerMode.
535  *
536  * Test that IComposerClient::setPowerMode succeeds for all power modes.
537  */
TEST_F(GraphicsComposerHidlTest,SetPowerMode)538 TEST_F(GraphicsComposerHidlTest, SetPowerMode) {
539     std::vector<IComposerClient::PowerMode> modes;
540     modes.push_back(IComposerClient::PowerMode::OFF);
541 
542     if (mComposerClient->getDozeSupport(mPrimaryDisplay)) {
543         modes.push_back(IComposerClient::PowerMode::DOZE);
544         modes.push_back(IComposerClient::PowerMode::DOZE_SUSPEND);
545     }
546 
547     // push ON last
548     modes.push_back(IComposerClient::PowerMode::ON);
549 
550     for (auto mode : modes) {
551         mComposerClient->setPowerMode(mPrimaryDisplay, mode);
552     }
553 }
554 
555 /**
556  * Test IComposerClient::setPowerMode
557  *
558  * Test IComposerClient::setPowerMode succeeds with different
559  * orderings of power modes
560  */
TEST_F(GraphicsComposerHidlTest,SetPowerModeVariations)561 TEST_F(GraphicsComposerHidlTest, SetPowerModeVariations) {
562     std::vector<IComposerClient::PowerMode> modes;
563     modes.push_back(IComposerClient::PowerMode::OFF);
564     modes.push_back(IComposerClient::PowerMode::ON);
565     modes.push_back(IComposerClient::PowerMode::OFF);
566     for (auto mode : modes) {
567         ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
568     }
569 
570     modes.clear();
571 
572     modes.push_back(IComposerClient::PowerMode::OFF);
573     modes.push_back(IComposerClient::PowerMode::OFF);
574     for (auto mode : modes) {
575         ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
576     }
577 
578     modes.clear();
579     if (mComposerClient->getDozeSupport(mPrimaryDisplay)) {
580         modes.push_back(IComposerClient::PowerMode::DOZE);
581         modes.push_back(IComposerClient::PowerMode::DOZE);
582 
583         for (auto mode : modes) {
584             ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
585         }
586 
587         modes.clear();
588 
589         modes.push_back(IComposerClient::PowerMode::DOZE_SUSPEND);
590         modes.push_back(IComposerClient::PowerMode::DOZE_SUSPEND);
591 
592         for (auto mode : modes) {
593             ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
594         }
595     }
596 
597     modes.clear();
598 
599     modes.push_back(IComposerClient::PowerMode::ON);
600     modes.push_back(IComposerClient::PowerMode::ON);
601     for (auto mode : modes) {
602         ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
603     }
604 }
605 
606 /**
607  * Test IComposerClient::setPowerMode
608  *
609  * Test IComposerClient::setPowerMode returns BAD_DISPLAY when passed an invalid
610  * display handle
611  */
TEST_F(GraphicsComposerHidlTest,SetPowerModeBadDisplay)612 TEST_F(GraphicsComposerHidlTest, SetPowerModeBadDisplay) {
613     Error error =
614         mComposerClient->getRaw()->setPowerMode(mInvalidDisplayId, IComposerClient::PowerMode::ON);
615     ASSERT_EQ(Error::BAD_DISPLAY, error);
616 }
617 
618 /**
619  * Test IComposerClient::setPowerMode
620  *
621  * Test that IComposerClient::setPowerMode returns UNSUPPORTED when passed DOZE
622  * or DOZE_SUSPEND on devices that do not support DOZE/DOZE_SUSPEND
623  */
TEST_F(GraphicsComposerHidlTest,SetPowerModeUnsupported)624 TEST_F(GraphicsComposerHidlTest, SetPowerModeUnsupported) {
625     if (!mComposerClient->getDozeSupport(mPrimaryDisplay)) {
626         Error error = mComposerClient->getRaw()->setPowerMode(mPrimaryDisplay,
627                                                               IComposerClient::PowerMode::DOZE);
628         EXPECT_EQ(Error::UNSUPPORTED, error);
629 
630         error = mComposerClient->getRaw()->setPowerMode(mPrimaryDisplay,
631                                                         IComposerClient::PowerMode::DOZE_SUSPEND);
632         EXPECT_EQ(Error::UNSUPPORTED, error);
633     }
634 }
635 
636 /**
637  * Test IComposerClient::setPowerMode
638  *
639  * Tests that IComposerClient::setPowerMode returns BAD_PARAMETER when passed an invalid
640  * PowerMode
641  */
TEST_F(GraphicsComposerHidlTest,SetPowerModeBadParameter)642 TEST_F(GraphicsComposerHidlTest, SetPowerModeBadParameter) {
643     Error error = mComposerClient->getRaw()->setPowerMode(
644         mPrimaryDisplay, static_cast<IComposerClient::PowerMode>(-1));
645     ASSERT_EQ(Error::BAD_PARAMETER, error);
646 }
647 
648 /**
649  * Test IComposerClient::setVsyncEnabled.
650  *
651  * Test that IComposerClient::setVsyncEnabled succeeds and there is no
652  * spurious vsync events.
653  */
TEST_F(GraphicsComposerHidlTest,SetVsyncEnabled)654 TEST_F(GraphicsComposerHidlTest, SetVsyncEnabled) {
655     mComposerCallback->setVsyncAllowed(true);
656 
657     mComposerClient->setVsyncEnabled(mPrimaryDisplay, true);
658     usleep(60 * 1000);
659     mComposerClient->setVsyncEnabled(mPrimaryDisplay, false);
660 
661     mComposerCallback->setVsyncAllowed(false);
662 }
663 
664 // Tests for IComposerClient::Command.
665 class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {
666    protected:
SetUp()667     void SetUp() override {
668         ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::SetUp());
669 
670         ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>());
671         Config activeConfig = mComposerClient->getActiveConfig(mPrimaryDisplay);
672         mDisplayWidth = mComposerClient->getDisplayAttribute(mPrimaryDisplay, activeConfig,
673                                                              IComposerClient::Attribute::WIDTH);
674         mDisplayHeight = mComposerClient->getDisplayAttribute(mPrimaryDisplay, activeConfig,
675                                                               IComposerClient::Attribute::HEIGHT);
676         mWriter = std::make_unique<CommandWriterBase>(1024);
677         mReader = std::make_unique<TestCommandReader>();
678     }
679 
TearDown()680     void TearDown() override {
681         ASSERT_EQ(0, mReader->mErrors.size());
682         ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::TearDown());
683     }
684 
allocate()685     const native_handle_t* allocate() {
686         uint64_t usage =
687                 static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN |
688                                       BufferUsage::COMPOSER_OVERLAY);
689         return mGralloc->allocate(mDisplayWidth, mDisplayHeight, 1, PixelFormat::RGBA_8888, usage);
690     }
691 
execute()692     void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); }
693 
694     std::unique_ptr<CommandWriterBase> mWriter;
695     std::unique_ptr<TestCommandReader> mReader;
696     int32_t mDisplayWidth;
697     int32_t mDisplayHeight;
698 
699    private:
700      std::unique_ptr<Gralloc> mGralloc;
701 };
702 
703 /**
704  * Test IComposerClient::Command::SET_COLOR_TRANSFORM.
705  */
TEST_F(GraphicsComposerHidlCommandTest,SET_COLOR_TRANSFORM)706 TEST_F(GraphicsComposerHidlCommandTest, SET_COLOR_TRANSFORM) {
707     const std::array<float, 16> identity = {{
708         1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
709         1.0f,
710     }};
711 
712     mWriter->selectDisplay(mPrimaryDisplay);
713     mWriter->setColorTransform(identity.data(), ColorTransform::IDENTITY);
714 
715     execute();
716 }
717 
718 /**
719  * Test IComposerClient::Command::SET_CLIENT_TARGET.
720  */
TEST_F(GraphicsComposerHidlCommandTest,SET_CLIENT_TARGET)721 TEST_F(GraphicsComposerHidlCommandTest, SET_CLIENT_TARGET) {
722     mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount);
723 
724     mWriter->selectDisplay(mPrimaryDisplay);
725     mWriter->setClientTarget(0, nullptr, -1, Dataspace::UNKNOWN,
726                              std::vector<IComposerClient::Rect>());
727 
728     execute();
729 }
730 
731 /**
732  * Test IComposerClient::Command::SET_OUTPUT_BUFFER.
733  */
TEST_F(GraphicsComposerHidlCommandTest,SET_OUTPUT_BUFFER)734 TEST_F(GraphicsComposerHidlCommandTest, SET_OUTPUT_BUFFER) {
735     if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
736         GTEST_SUCCEED() << "no virtual display support";
737         return;
738     }
739 
740     Display display;
741     PixelFormat format;
742     ASSERT_NO_FATAL_FAILURE(
743         display = mComposerClient->createVirtualDisplay(64, 64, PixelFormat::IMPLEMENTATION_DEFINED,
744                                                         kBufferSlotCount, &format));
745 
746     const native_handle_t* handle;
747     ASSERT_NO_FATAL_FAILURE(handle = allocate());
748 
749     mWriter->selectDisplay(display);
750     mWriter->setOutputBuffer(0, handle, -1);
751     execute();
752 }
753 
754 /**
755  * Test IComposerClient::Command::VALIDATE_DISPLAY.
756  */
TEST_F(GraphicsComposerHidlCommandTest,VALIDATE_DISPLAY)757 TEST_F(GraphicsComposerHidlCommandTest, VALIDATE_DISPLAY) {
758     mWriter->selectDisplay(mPrimaryDisplay);
759     mWriter->validateDisplay();
760     execute();
761 }
762 
763 /**
764  * Test IComposerClient::Command::ACCEPT_DISPLAY_CHANGES.
765  */
TEST_F(GraphicsComposerHidlCommandTest,ACCEPT_DISPLAY_CHANGES)766 TEST_F(GraphicsComposerHidlCommandTest, ACCEPT_DISPLAY_CHANGES) {
767     mWriter->selectDisplay(mPrimaryDisplay);
768     mWriter->validateDisplay();
769     mWriter->acceptDisplayChanges();
770     execute();
771 }
772 
773 /**
774  * Test IComposerClient::Command::PRESENT_DISPLAY.
775  */
TEST_F(GraphicsComposerHidlCommandTest,PRESENT_DISPLAY)776 TEST_F(GraphicsComposerHidlCommandTest, PRESENT_DISPLAY) {
777     mWriter->selectDisplay(mPrimaryDisplay);
778     mWriter->validateDisplay();
779     mWriter->presentDisplay();
780     execute();
781 }
782 
783 /**
784  * Test IComposerClient::Command::PRESENT_DISPLAY
785  *
786  * Test that IComposerClient::Command::PRESENT_DISPLAY works without
787  * additional call to validateDisplay when only the layer buffer handle and
788  * surface damage have been set
789  */
TEST_F(GraphicsComposerHidlCommandTest,PRESENT_DISPLAY_NO_LAYER_STATE_CHANGES)790 TEST_F(GraphicsComposerHidlCommandTest, PRESENT_DISPLAY_NO_LAYER_STATE_CHANGES) {
791     mWriter->selectDisplay(mPrimaryDisplay);
792     mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::ON);
793     mComposerClient->setColorMode(mPrimaryDisplay, ColorMode::NATIVE);
794 
795     auto handle = allocate();
796     ASSERT_NE(nullptr, handle);
797 
798     IComposerClient::Rect displayFrame{0, 0, mDisplayWidth, mDisplayHeight};
799 
800     Layer layer;
801     ASSERT_NO_FATAL_FAILURE(layer =
802                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
803     mWriter->selectLayer(layer);
804     mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
805     mWriter->setLayerDisplayFrame(displayFrame);
806     mWriter->setLayerPlaneAlpha(1);
807     mWriter->setLayerSourceCrop({0, 0, (float)mDisplayWidth, (float)mDisplayHeight});
808     mWriter->setLayerTransform(static_cast<Transform>(0));
809     mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, displayFrame));
810     mWriter->setLayerZOrder(10);
811     mWriter->setLayerBlendMode(IComposerClient::BlendMode::NONE);
812     mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, displayFrame));
813     mWriter->setLayerBuffer(0, handle, -1);
814     mWriter->setLayerDataspace(Dataspace::UNKNOWN);
815 
816     mWriter->validateDisplay();
817     execute();
818     if (mReader->mCompositionChanges.size() != 0) {
819         GTEST_SUCCEED() << "Composition change requested, skipping test";
820         return;
821     }
822 
823     ASSERT_EQ(0, mReader->mErrors.size());
824     mWriter->presentDisplay();
825     execute();
826     ASSERT_EQ(0, mReader->mErrors.size());
827 
828     mWriter->selectLayer(layer);
829     auto handle2 = allocate();
830     ASSERT_NE(nullptr, handle2);
831     mWriter->setLayerBuffer(0, handle2, -1);
832     mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, {0, 0, 10, 10}));
833     mWriter->presentDisplay();
834     execute();
835 }
836 
837 /**
838  * Test IComposerClient::Command::SET_LAYER_CURSOR_POSITION.
839  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_CURSOR_POSITION)840 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_CURSOR_POSITION) {
841     Layer layer;
842     ASSERT_NO_FATAL_FAILURE(layer =
843                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
844 
845     auto handle = allocate();
846     ASSERT_NE(nullptr, handle);
847     IComposerClient::Rect displayFrame{0, 0, mDisplayWidth, mDisplayHeight};
848 
849     mWriter->selectDisplay(mPrimaryDisplay);
850     mWriter->selectLayer(layer);
851     mWriter->setLayerBuffer(0, handle, -1);
852     mWriter->setLayerCompositionType(IComposerClient::Composition::CURSOR);
853     mWriter->setLayerDisplayFrame(displayFrame);
854     mWriter->setLayerPlaneAlpha(1);
855     mWriter->setLayerSourceCrop({0, 0, (float)mDisplayWidth, (float)mDisplayHeight});
856     mWriter->setLayerTransform(static_cast<Transform>(0));
857     mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, displayFrame));
858     mWriter->setLayerZOrder(10);
859     mWriter->setLayerBlendMode(IComposerClient::BlendMode::NONE);
860     mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, displayFrame));
861     mWriter->setLayerDataspace(Dataspace::UNKNOWN);
862     mWriter->validateDisplay();
863 
864     execute();
865     if (mReader->mCompositionChanges.size() != 0) {
866         GTEST_SUCCEED() << "Composition change requested, skipping test";
867         return;
868     }
869     mWriter->presentDisplay();
870     ASSERT_EQ(0, mReader->mErrors.size());
871 
872     mWriter->setLayerCursorPosition(1, 1);
873     mWriter->setLayerCursorPosition(0, 0);
874     mWriter->validateDisplay();
875     mWriter->presentDisplay();
876     execute();
877 }
878 
879 /**
880  * Test IComposerClient::Command::SET_LAYER_BUFFER.
881  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_BUFFER)882 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_BUFFER) {
883     auto handle = allocate();
884     ASSERT_NE(nullptr, handle);
885 
886     Layer layer;
887     ASSERT_NO_FATAL_FAILURE(layer =
888                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
889 
890     mWriter->selectDisplay(mPrimaryDisplay);
891     mWriter->selectLayer(layer);
892     mWriter->setLayerBuffer(0, handle, -1);
893     execute();
894 }
895 
896 /**
897  * Test IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE.
898  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_SURFACE_DAMAGE)899 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_SURFACE_DAMAGE) {
900     Layer layer;
901     ASSERT_NO_FATAL_FAILURE(layer =
902                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
903 
904     IComposerClient::Rect empty{0, 0, 0, 0};
905     IComposerClient::Rect unit{0, 0, 1, 1};
906 
907     mWriter->selectDisplay(mPrimaryDisplay);
908     mWriter->selectLayer(layer);
909     mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, empty));
910     mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, unit));
911     mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>());
912     execute();
913 }
914 
915 /**
916  * Test IComposerClient::Command::SET_LAYER_BLEND_MODE.
917  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_BLEND_MODE)918 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_BLEND_MODE) {
919     Layer layer;
920     ASSERT_NO_FATAL_FAILURE(layer =
921                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
922 
923     mWriter->selectDisplay(mPrimaryDisplay);
924     mWriter->selectLayer(layer);
925     mWriter->setLayerBlendMode(IComposerClient::BlendMode::NONE);
926     mWriter->setLayerBlendMode(IComposerClient::BlendMode::PREMULTIPLIED);
927     mWriter->setLayerBlendMode(IComposerClient::BlendMode::COVERAGE);
928     execute();
929 }
930 
931 /**
932  * Test IComposerClient::Command::SET_LAYER_COLOR.
933  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_COLOR)934 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_COLOR) {
935     Layer layer;
936     ASSERT_NO_FATAL_FAILURE(layer =
937                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
938 
939     mWriter->selectDisplay(mPrimaryDisplay);
940     mWriter->selectLayer(layer);
941     mWriter->setLayerColor(IComposerClient::Color{0xff, 0xff, 0xff, 0xff});
942     mWriter->setLayerColor(IComposerClient::Color{0, 0, 0, 0});
943     execute();
944 }
945 
946 /**
947  * Test IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE.
948  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_COMPOSITION_TYPE)949 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_COMPOSITION_TYPE) {
950     Layer layer;
951     ASSERT_NO_FATAL_FAILURE(layer =
952                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
953 
954     mWriter->selectDisplay(mPrimaryDisplay);
955     mWriter->selectLayer(layer);
956     mWriter->setLayerCompositionType(IComposerClient::Composition::CLIENT);
957     mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
958     mWriter->setLayerCompositionType(IComposerClient::Composition::SOLID_COLOR);
959     mWriter->setLayerCompositionType(IComposerClient::Composition::CURSOR);
960     execute();
961 }
962 
963 /**
964  * Test IComposerClient::Command::SET_LAYER_DATASPACE.
965  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_DATASPACE)966 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_DATASPACE) {
967     Layer layer;
968     ASSERT_NO_FATAL_FAILURE(layer =
969                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
970 
971     mWriter->selectDisplay(mPrimaryDisplay);
972     mWriter->selectLayer(layer);
973     mWriter->setLayerDataspace(Dataspace::UNKNOWN);
974     execute();
975 }
976 
977 /**
978  * Test IComposerClient::Command::SET_LAYER_DISPLAY_FRAME.
979  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_DISPLAY_FRAME)980 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_DISPLAY_FRAME) {
981     Layer layer;
982     ASSERT_NO_FATAL_FAILURE(layer =
983                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
984 
985     mWriter->selectDisplay(mPrimaryDisplay);
986     mWriter->selectLayer(layer);
987     mWriter->setLayerDisplayFrame(IComposerClient::Rect{0, 0, 1, 1});
988     execute();
989 }
990 
991 /**
992  * Test IComposerClient::Command::SET_LAYER_PLANE_ALPHA.
993  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_PLANE_ALPHA)994 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_PLANE_ALPHA) {
995     Layer layer;
996     ASSERT_NO_FATAL_FAILURE(layer =
997                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
998 
999     mWriter->selectDisplay(mPrimaryDisplay);
1000     mWriter->selectLayer(layer);
1001     mWriter->setLayerPlaneAlpha(0.0f);
1002     mWriter->setLayerPlaneAlpha(1.0f);
1003     execute();
1004 }
1005 
1006 /**
1007  * Test IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM.
1008  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_SIDEBAND_STREAM)1009 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_SIDEBAND_STREAM) {
1010     if (!mComposer->hasCapability(IComposer::Capability::SIDEBAND_STREAM)) {
1011         GTEST_SUCCEED() << "no sideband stream support";
1012         return;
1013     }
1014 
1015     auto handle = allocate();
1016     ASSERT_NE(nullptr, handle);
1017 
1018     Layer layer;
1019     ASSERT_NO_FATAL_FAILURE(layer =
1020                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1021 
1022     mWriter->selectDisplay(mPrimaryDisplay);
1023     mWriter->selectLayer(layer);
1024     mWriter->setLayerSidebandStream(handle);
1025     execute();
1026 }
1027 
1028 /**
1029  * Test IComposerClient::Command::SET_LAYER_SOURCE_CROP.
1030  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_SOURCE_CROP)1031 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_SOURCE_CROP) {
1032     Layer layer;
1033     ASSERT_NO_FATAL_FAILURE(layer =
1034                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1035 
1036     mWriter->selectDisplay(mPrimaryDisplay);
1037     mWriter->selectLayer(layer);
1038     mWriter->setLayerSourceCrop(IComposerClient::FRect{0.0f, 0.0f, 1.0f, 1.0f});
1039     execute();
1040 }
1041 
1042 /**
1043  * Test IComposerClient::Command::SET_LAYER_TRANSFORM.
1044  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_TRANSFORM)1045 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_TRANSFORM) {
1046     Layer layer;
1047     ASSERT_NO_FATAL_FAILURE(layer =
1048                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1049 
1050     mWriter->selectDisplay(mPrimaryDisplay);
1051     mWriter->selectLayer(layer);
1052     mWriter->setLayerTransform(static_cast<Transform>(0));
1053     mWriter->setLayerTransform(Transform::FLIP_H);
1054     mWriter->setLayerTransform(Transform::FLIP_V);
1055     mWriter->setLayerTransform(Transform::ROT_90);
1056     mWriter->setLayerTransform(Transform::ROT_180);
1057     mWriter->setLayerTransform(Transform::ROT_270);
1058     mWriter->setLayerTransform(static_cast<Transform>(Transform::FLIP_H | Transform::ROT_90));
1059     mWriter->setLayerTransform(static_cast<Transform>(Transform::FLIP_V | Transform::ROT_90));
1060     execute();
1061 }
1062 
1063 /**
1064  * Test IComposerClient::Command::SET_LAYER_VISIBLE_REGION.
1065  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_VISIBLE_REGION)1066 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_VISIBLE_REGION) {
1067     Layer layer;
1068     ASSERT_NO_FATAL_FAILURE(layer =
1069                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1070 
1071     IComposerClient::Rect empty{0, 0, 0, 0};
1072     IComposerClient::Rect unit{0, 0, 1, 1};
1073 
1074     mWriter->selectDisplay(mPrimaryDisplay);
1075     mWriter->selectLayer(layer);
1076     mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, empty));
1077     mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, unit));
1078     mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>());
1079     execute();
1080 }
1081 
1082 /**
1083  * Test IComposerClient::Command::SET_LAYER_Z_ORDER.
1084  */
TEST_F(GraphicsComposerHidlCommandTest,SET_LAYER_Z_ORDER)1085 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_Z_ORDER) {
1086     Layer layer;
1087     ASSERT_NO_FATAL_FAILURE(layer =
1088                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1089 
1090     mWriter->selectDisplay(mPrimaryDisplay);
1091     mWriter->selectLayer(layer);
1092     mWriter->setLayerZOrder(10);
1093     mWriter->setLayerZOrder(0);
1094     execute();
1095 }
1096 
1097 }  // namespace
1098 }  // namespace vts
1099 }  // namespace V2_1
1100 }  // namespace composer
1101 }  // namespace graphics
1102 }  // namespace hardware
1103 }  // namespace android
1104 
main(int argc,char ** argv)1105 int main(int argc, char** argv) {
1106     using android::hardware::graphics::composer::V2_1::vts::GraphicsComposerHidlEnvironment;
1107     ::testing::AddGlobalTestEnvironment(GraphicsComposerHidlEnvironment::Instance());
1108     ::testing::InitGoogleTest(&argc, argv);
1109     GraphicsComposerHidlEnvironment::Instance()->init(&argc, argv);
1110     int status = RUN_ALL_TESTS();
1111     ALOGI("Test result = %d", status);
1112     return status;
1113 }
1114