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
25#include <VtsHalHidlTargetTestBase.h>
26#include <VtsHalHidlTargetTestEnvBase.h>
27#include <unistd.h>
28
29#include <algorithm>
30#include <array>
31#include <memory>
32#include <mutex>
33#include <unordered_set>
34#include <vector>
35
36namespace android {
37namespace hardware {
38namespace graphics {
39namespace composer {
40namespace V2_1 {
41namespace vts {
42namespace {
43
44using android::hardware::graphics::common::V1_0::BufferUsage;
45using android::hardware::graphics::common::V1_0::ColorMode;
46using android::hardware::graphics::common::V1_0::ColorTransform;
47using android::hardware::graphics::common::V1_0::Dataspace;
48using android::hardware::graphics::common::V1_0::PixelFormat;
49using android::hardware::graphics::common::V1_0::Transform;
50using android::hardware::graphics::mapper::V2_0::IMapper;
51using android::hardware::graphics::mapper::V2_0::vts::Gralloc;
52using GrallocError = android::hardware::graphics::mapper::V2_0::Error;
53
54// Test environment for graphics.composer
55class GraphicsComposerHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
56   public:
57    // get the test environment singleton
58    static GraphicsComposerHidlEnvironment* Instance() {
59        static GraphicsComposerHidlEnvironment* instance = new GraphicsComposerHidlEnvironment;
60        return instance;
61    }
62
63    virtual void registerTestServices() override { registerTestService<IComposer>(); }
64
65   private:
66    GraphicsComposerHidlEnvironment() {}
67
68    GTEST_DISALLOW_COPY_AND_ASSIGN_(GraphicsComposerHidlEnvironment);
69};
70
71class GraphicsComposerHidlTest : public ::testing::VtsHalHidlTargetTestBase {
72   protected:
73    void SetUp() override {
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
90    void TearDown() override {
91        if (mComposerCallback != nullptr) {
92            EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
93            EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
94            EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
95        }
96    }
97
98    // use the slot count usually set by SF
99    static constexpr uint32_t kBufferSlotCount = 64;
100
101    std::unique_ptr<Composer> mComposer;
102    std::unique_ptr<ComposerClient> mComposerClient;
103    sp<GraphicsComposerCallback> mComposerCallback;
104    // the first display and is assumed never to be removed
105    Display mPrimaryDisplay;
106
107   private:
108    Display waitForFirstDisplay() {
109        while (true) {
110            std::vector<Display> displays = mComposerCallback->getDisplays();
111            if (displays.empty()) {
112                usleep(5 * 1000);
113                continue;
114            }
115
116            return displays[0];
117        }
118    }
119};
120
121/**
122 * Test IComposer::getCapabilities.
123 *
124 * Test that IComposer::getCapabilities returns no invalid capabilities.
125 */
126TEST_F(GraphicsComposerHidlTest, GetCapabilities) {
127    auto capabilities = mComposer->getCapabilities();
128    ASSERT_EQ(capabilities.end(),
129              std::find(capabilities.begin(), capabilities.end(), IComposer::Capability::INVALID));
130}
131
132/**
133 * Test IComposer::dumpDebugInfo.
134 */
135TEST_F(GraphicsComposerHidlTest, DumpDebugInfo) {
136    mComposer->dumpDebugInfo();
137}
138
139/**
140 * Test IComposer::createClient.
141 *
142 * Test that IComposerClient is a singleton.
143 */
144TEST_F(GraphicsComposerHidlTest, CreateClientSingleton) {
145    mComposer->getRaw()->createClient(
146        [&](const auto& tmpError, const auto&) { EXPECT_EQ(Error::NO_RESOURCES, tmpError); });
147}
148
149/**
150 * Test IComposerClient::createVirtualDisplay and
151 * IComposerClient::destroyVirtualDisplay.
152 *
153 * Test that virtual displays can be created and has the correct display type.
154 */
155TEST_F(GraphicsComposerHidlTest, CreateVirtualDisplay) {
156    if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
157        GTEST_SUCCEED() << "no virtual display support";
158        return;
159    }
160
161    Display display;
162    PixelFormat format;
163    ASSERT_NO_FATAL_FAILURE(
164        display = mComposerClient->createVirtualDisplay(64, 64, PixelFormat::IMPLEMENTATION_DEFINED,
165                                                        kBufferSlotCount, &format));
166
167    // test display type
168    IComposerClient::DisplayType type = mComposerClient->getDisplayType(display);
169    EXPECT_EQ(IComposerClient::DisplayType::VIRTUAL, type);
170
171    mComposerClient->destroyVirtualDisplay(display);
172}
173
174/**
175 * Test IComposerClient::createLayer and IComposerClient::destroyLayer.
176 *
177 * Test that layers can be created and destroyed.
178 */
179TEST_F(GraphicsComposerHidlTest, CreateLayer) {
180    Layer layer;
181    ASSERT_NO_FATAL_FAILURE(layer =
182                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
183
184    mComposerClient->destroyLayer(mPrimaryDisplay, layer);
185}
186
187/**
188 * Test IComposerClient::getDisplayName.
189 */
190TEST_F(GraphicsComposerHidlTest, GetDisplayName) {
191    mComposerClient->getDisplayName(mPrimaryDisplay);
192}
193
194/**
195 * Test IComposerClient::getDisplayType.
196 *
197 * Test that IComposerClient::getDisplayType returns the correct display type
198 * for the primary display.
199 */
200TEST_F(GraphicsComposerHidlTest, GetDisplayType) {
201    ASSERT_EQ(IComposerClient::DisplayType::PHYSICAL,
202              mComposerClient->getDisplayType(mPrimaryDisplay));
203}
204
205/**
206 * Test IComposerClient::getClientTargetSupport.
207 *
208 * Test that IComposerClient::getClientTargetSupport returns true for the
209 * required client targets.
210 */
211TEST_F(GraphicsComposerHidlTest, GetClientTargetSupport) {
212    std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
213    for (auto config : configs) {
214        int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
215                                                             IComposerClient::Attribute::WIDTH);
216        int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
217                                                              IComposerClient::Attribute::HEIGHT);
218        ASSERT_LT(0, width);
219        ASSERT_LT(0, height);
220
221        mComposerClient->setActiveConfig(mPrimaryDisplay, config);
222
223        ASSERT_TRUE(mComposerClient->getClientTargetSupport(
224            mPrimaryDisplay, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN));
225    }
226}
227
228/**
229 * Test IComposerClient::getDisplayAttribute.
230 *
231 * Test that IComposerClient::getDisplayAttribute succeeds for the required
232 * formats, and succeeds or fails correctly for optional attributes.
233 */
234TEST_F(GraphicsComposerHidlTest, GetDisplayAttribute) {
235    std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
236    for (auto config : configs) {
237        const std::array<IComposerClient::Attribute, 3> requiredAttributes = {{
238            IComposerClient::Attribute::WIDTH, IComposerClient::Attribute::HEIGHT,
239            IComposerClient::Attribute::VSYNC_PERIOD,
240        }};
241        for (auto attribute : requiredAttributes) {
242            mComposerClient->getDisplayAttribute(mPrimaryDisplay, config, attribute);
243        }
244
245        const std::array<IComposerClient::Attribute, 2> optionalAttributes = {{
246            IComposerClient::Attribute::DPI_X, IComposerClient::Attribute::DPI_Y,
247        }};
248        for (auto attribute : optionalAttributes) {
249            mComposerClient->getRaw()->getDisplayAttribute(
250                mPrimaryDisplay, config, attribute, [&](const auto& tmpError, const auto&) {
251                    EXPECT_TRUE(tmpError == Error::NONE || tmpError == Error::UNSUPPORTED);
252                });
253        }
254    }
255}
256
257/**
258 * Test IComposerClient::getHdrCapabilities.
259 */
260TEST_F(GraphicsComposerHidlTest, GetHdrCapabilities) {
261    float maxLuminance;
262    float maxAverageLuminance;
263    float minLuminance;
264    mComposerClient->getHdrCapabilities(mPrimaryDisplay, &maxLuminance, &maxAverageLuminance,
265                                        &minLuminance);
266}
267
268/**
269 * Test IComposerClient::setClientTargetSlotCount.
270 */
271TEST_F(GraphicsComposerHidlTest, SetClientTargetSlotCount) {
272    mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount);
273}
274
275/**
276 * Test IComposerClient::setActiveConfig.
277 *
278 * Test that IComposerClient::setActiveConfig succeeds for all display
279 * configs.
280 */
281TEST_F(GraphicsComposerHidlTest, SetActiveConfig) {
282    std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
283    for (auto config : configs) {
284        mComposerClient->setActiveConfig(mPrimaryDisplay, config);
285        ASSERT_EQ(config, mComposerClient->getActiveConfig(mPrimaryDisplay));
286    }
287}
288
289/**
290 * Test IComposerClient::setColorMode.
291 *
292 * Test that IComposerClient::setColorMode succeeds for all color modes.
293 */
294TEST_F(GraphicsComposerHidlTest, SetColorMode) {
295    std::unordered_set<ColorMode> validModes;
296    for (auto mode : hidl_enum_iterator<ColorMode>()) {
297        validModes.insert(mode);
298    }
299
300    std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
301    for (auto mode : modes) {
302        if (validModes.count(mode)) {
303            mComposerClient->setColorMode(mPrimaryDisplay, mode);
304        }
305    }
306}
307
308/**
309 * Test IComposerClient::setPowerMode.
310 *
311 * Test that IComposerClient::setPowerMode succeeds for all power modes.
312 */
313TEST_F(GraphicsComposerHidlTest, SetPowerMode) {
314    std::vector<IComposerClient::PowerMode> modes;
315    modes.push_back(IComposerClient::PowerMode::OFF);
316
317    if (mComposerClient->getDozeSupport(mPrimaryDisplay)) {
318        modes.push_back(IComposerClient::PowerMode::DOZE);
319        modes.push_back(IComposerClient::PowerMode::DOZE_SUSPEND);
320    }
321
322    // push ON last
323    modes.push_back(IComposerClient::PowerMode::ON);
324
325    for (auto mode : modes) {
326        mComposerClient->setPowerMode(mPrimaryDisplay, mode);
327    }
328}
329
330/**
331 * Test IComposerClient::setVsyncEnabled.
332 *
333 * Test that IComposerClient::setVsyncEnabled succeeds and there is no
334 * spurious vsync events.
335 */
336TEST_F(GraphicsComposerHidlTest, SetVsyncEnabled) {
337    mComposerCallback->setVsyncAllowed(true);
338
339    mComposerClient->setVsyncEnabled(mPrimaryDisplay, true);
340    usleep(60 * 1000);
341    mComposerClient->setVsyncEnabled(mPrimaryDisplay, false);
342
343    mComposerCallback->setVsyncAllowed(false);
344}
345
346// Tests for IComposerClient::Command.
347class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {
348   protected:
349    void SetUp() override {
350        ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::SetUp());
351
352        ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>());
353
354        mWriter = std::make_unique<CommandWriterBase>(1024);
355        mReader = std::make_unique<TestCommandReader>();
356    }
357
358    void TearDown() override { ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::TearDown()); }
359
360    const native_handle_t* allocate() {
361        IMapper::BufferDescriptorInfo info{};
362        info.width = 64;
363        info.height = 64;
364        info.layerCount = 1;
365        info.format = PixelFormat::RGBA_8888;
366        info.usage =
367            static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN);
368
369        return mGralloc->allocate(info);
370    }
371
372    void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); }
373
374    std::unique_ptr<CommandWriterBase> mWriter;
375    std::unique_ptr<TestCommandReader> mReader;
376
377   private:
378    std::unique_ptr<Gralloc> mGralloc;
379};
380
381/**
382 * Test IComposerClient::Command::SET_COLOR_TRANSFORM.
383 */
384TEST_F(GraphicsComposerHidlCommandTest, SET_COLOR_TRANSFORM) {
385    const std::array<float, 16> identity = {{
386        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,
387        1.0f,
388    }};
389
390    mWriter->selectDisplay(mPrimaryDisplay);
391    mWriter->setColorTransform(identity.data(), ColorTransform::IDENTITY);
392
393    execute();
394}
395
396/**
397 * Test IComposerClient::Command::SET_CLIENT_TARGET.
398 */
399TEST_F(GraphicsComposerHidlCommandTest, SET_CLIENT_TARGET) {
400    mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount);
401
402    mWriter->selectDisplay(mPrimaryDisplay);
403    mWriter->setClientTarget(0, nullptr, -1, Dataspace::UNKNOWN,
404                             std::vector<IComposerClient::Rect>());
405
406    execute();
407}
408
409/**
410 * Test IComposerClient::Command::SET_OUTPUT_BUFFER.
411 */
412TEST_F(GraphicsComposerHidlCommandTest, SET_OUTPUT_BUFFER) {
413    if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
414        GTEST_SUCCEED() << "no virtual display support";
415        return;
416    }
417
418    Display display;
419    PixelFormat format;
420    ASSERT_NO_FATAL_FAILURE(
421        display = mComposerClient->createVirtualDisplay(64, 64, PixelFormat::IMPLEMENTATION_DEFINED,
422                                                        kBufferSlotCount, &format));
423
424    const native_handle_t* handle;
425    ASSERT_NO_FATAL_FAILURE(handle = allocate());
426
427    mWriter->selectDisplay(display);
428    mWriter->setOutputBuffer(0, handle, -1);
429    execute();
430}
431
432/**
433 * Test IComposerClient::Command::VALIDATE_DISPLAY.
434 */
435TEST_F(GraphicsComposerHidlCommandTest, VALIDATE_DISPLAY) {
436    mWriter->selectDisplay(mPrimaryDisplay);
437    mWriter->validateDisplay();
438    execute();
439}
440
441/**
442 * Test IComposerClient::Command::ACCEPT_DISPLAY_CHANGES.
443 */
444TEST_F(GraphicsComposerHidlCommandTest, ACCEPT_DISPLAY_CHANGES) {
445    mWriter->selectDisplay(mPrimaryDisplay);
446    mWriter->validateDisplay();
447    mWriter->acceptDisplayChanges();
448    execute();
449}
450
451/**
452 * Test IComposerClient::Command::PRESENT_DISPLAY.
453 */
454TEST_F(GraphicsComposerHidlCommandTest, PRESENT_DISPLAY) {
455    mWriter->selectDisplay(mPrimaryDisplay);
456    mWriter->validateDisplay();
457    mWriter->presentDisplay();
458    execute();
459}
460
461/**
462 * Test IComposerClient::Command::SET_LAYER_CURSOR_POSITION.
463 */
464TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_CURSOR_POSITION) {
465    Layer layer;
466    ASSERT_NO_FATAL_FAILURE(layer =
467                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
468
469    mWriter->selectDisplay(mPrimaryDisplay);
470    mWriter->selectLayer(layer);
471    mWriter->setLayerCursorPosition(1, 1);
472    mWriter->setLayerCursorPosition(0, 0);
473    execute();
474}
475
476/**
477 * Test IComposerClient::Command::SET_LAYER_BUFFER.
478 */
479TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_BUFFER) {
480    auto handle = allocate();
481    ASSERT_NE(nullptr, handle);
482
483    Layer layer;
484    ASSERT_NO_FATAL_FAILURE(layer =
485                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
486
487    mWriter->selectDisplay(mPrimaryDisplay);
488    mWriter->selectLayer(layer);
489    mWriter->setLayerBuffer(0, handle, -1);
490    execute();
491}
492
493/**
494 * Test IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE.
495 */
496TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_SURFACE_DAMAGE) {
497    Layer layer;
498    ASSERT_NO_FATAL_FAILURE(layer =
499                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
500
501    IComposerClient::Rect empty{0, 0, 0, 0};
502    IComposerClient::Rect unit{0, 0, 1, 1};
503
504    mWriter->selectDisplay(mPrimaryDisplay);
505    mWriter->selectLayer(layer);
506    mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, empty));
507    mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, unit));
508    mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>());
509    execute();
510}
511
512/**
513 * Test IComposerClient::Command::SET_LAYER_BLEND_MODE.
514 */
515TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_BLEND_MODE) {
516    Layer layer;
517    ASSERT_NO_FATAL_FAILURE(layer =
518                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
519
520    mWriter->selectDisplay(mPrimaryDisplay);
521    mWriter->selectLayer(layer);
522    mWriter->setLayerBlendMode(IComposerClient::BlendMode::NONE);
523    mWriter->setLayerBlendMode(IComposerClient::BlendMode::PREMULTIPLIED);
524    mWriter->setLayerBlendMode(IComposerClient::BlendMode::COVERAGE);
525    execute();
526}
527
528/**
529 * Test IComposerClient::Command::SET_LAYER_COLOR.
530 */
531TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_COLOR) {
532    Layer layer;
533    ASSERT_NO_FATAL_FAILURE(layer =
534                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
535
536    mWriter->selectDisplay(mPrimaryDisplay);
537    mWriter->selectLayer(layer);
538    mWriter->setLayerColor(IComposerClient::Color{0xff, 0xff, 0xff, 0xff});
539    mWriter->setLayerColor(IComposerClient::Color{0, 0, 0, 0});
540    execute();
541}
542
543/**
544 * Test IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE.
545 */
546TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_COMPOSITION_TYPE) {
547    Layer layer;
548    ASSERT_NO_FATAL_FAILURE(layer =
549                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
550
551    mWriter->selectDisplay(mPrimaryDisplay);
552    mWriter->selectLayer(layer);
553    mWriter->setLayerCompositionType(IComposerClient::Composition::CLIENT);
554    mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
555    mWriter->setLayerCompositionType(IComposerClient::Composition::SOLID_COLOR);
556    mWriter->setLayerCompositionType(IComposerClient::Composition::CURSOR);
557    execute();
558}
559
560/**
561 * Test IComposerClient::Command::SET_LAYER_DATASPACE.
562 */
563TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_DATASPACE) {
564    Layer layer;
565    ASSERT_NO_FATAL_FAILURE(layer =
566                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
567
568    mWriter->selectDisplay(mPrimaryDisplay);
569    mWriter->selectLayer(layer);
570    mWriter->setLayerDataspace(Dataspace::UNKNOWN);
571    execute();
572}
573
574/**
575 * Test IComposerClient::Command::SET_LAYER_DISPLAY_FRAME.
576 */
577TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_DISPLAY_FRAME) {
578    Layer layer;
579    ASSERT_NO_FATAL_FAILURE(layer =
580                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
581
582    mWriter->selectDisplay(mPrimaryDisplay);
583    mWriter->selectLayer(layer);
584    mWriter->setLayerDisplayFrame(IComposerClient::Rect{0, 0, 1, 1});
585    execute();
586}
587
588/**
589 * Test IComposerClient::Command::SET_LAYER_PLANE_ALPHA.
590 */
591TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_PLANE_ALPHA) {
592    Layer layer;
593    ASSERT_NO_FATAL_FAILURE(layer =
594                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
595
596    mWriter->selectDisplay(mPrimaryDisplay);
597    mWriter->selectLayer(layer);
598    mWriter->setLayerPlaneAlpha(0.0f);
599    mWriter->setLayerPlaneAlpha(1.0f);
600    execute();
601}
602
603/**
604 * Test IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM.
605 */
606TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_SIDEBAND_STREAM) {
607    if (!mComposer->hasCapability(IComposer::Capability::SIDEBAND_STREAM)) {
608        GTEST_SUCCEED() << "no sideband stream support";
609        return;
610    }
611
612    auto handle = allocate();
613    ASSERT_NE(nullptr, handle);
614
615    Layer layer;
616    ASSERT_NO_FATAL_FAILURE(layer =
617                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
618
619    mWriter->selectDisplay(mPrimaryDisplay);
620    mWriter->selectLayer(layer);
621    mWriter->setLayerSidebandStream(handle);
622    execute();
623}
624
625/**
626 * Test IComposerClient::Command::SET_LAYER_SOURCE_CROP.
627 */
628TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_SOURCE_CROP) {
629    Layer layer;
630    ASSERT_NO_FATAL_FAILURE(layer =
631                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
632
633    mWriter->selectDisplay(mPrimaryDisplay);
634    mWriter->selectLayer(layer);
635    mWriter->setLayerSourceCrop(IComposerClient::FRect{0.0f, 0.0f, 1.0f, 1.0f});
636    execute();
637}
638
639/**
640 * Test IComposerClient::Command::SET_LAYER_TRANSFORM.
641 */
642TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_TRANSFORM) {
643    Layer layer;
644    ASSERT_NO_FATAL_FAILURE(layer =
645                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
646
647    mWriter->selectDisplay(mPrimaryDisplay);
648    mWriter->selectLayer(layer);
649    mWriter->setLayerTransform(static_cast<Transform>(0));
650    mWriter->setLayerTransform(Transform::FLIP_H);
651    mWriter->setLayerTransform(Transform::FLIP_V);
652    mWriter->setLayerTransform(Transform::ROT_90);
653    mWriter->setLayerTransform(Transform::ROT_180);
654    mWriter->setLayerTransform(Transform::ROT_270);
655    mWriter->setLayerTransform(static_cast<Transform>(Transform::FLIP_H | Transform::ROT_90));
656    mWriter->setLayerTransform(static_cast<Transform>(Transform::FLIP_V | Transform::ROT_90));
657    execute();
658}
659
660/**
661 * Test IComposerClient::Command::SET_LAYER_VISIBLE_REGION.
662 */
663TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_VISIBLE_REGION) {
664    Layer layer;
665    ASSERT_NO_FATAL_FAILURE(layer =
666                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
667
668    IComposerClient::Rect empty{0, 0, 0, 0};
669    IComposerClient::Rect unit{0, 0, 1, 1};
670
671    mWriter->selectDisplay(mPrimaryDisplay);
672    mWriter->selectLayer(layer);
673    mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, empty));
674    mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, unit));
675    mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>());
676    execute();
677}
678
679/**
680 * Test IComposerClient::Command::SET_LAYER_Z_ORDER.
681 */
682TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_Z_ORDER) {
683    Layer layer;
684    ASSERT_NO_FATAL_FAILURE(layer =
685                                mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
686
687    mWriter->selectDisplay(mPrimaryDisplay);
688    mWriter->selectLayer(layer);
689    mWriter->setLayerZOrder(10);
690    mWriter->setLayerZOrder(0);
691    execute();
692}
693
694}  // namespace
695}  // namespace vts
696}  // namespace V2_1
697}  // namespace composer
698}  // namespace graphics
699}  // namespace hardware
700}  // namespace android
701
702int main(int argc, char** argv) {
703    using android::hardware::graphics::composer::V2_1::vts::GraphicsComposerHidlEnvironment;
704    ::testing::AddGlobalTestEnvironment(GraphicsComposerHidlEnvironment::Instance());
705    ::testing::InitGoogleTest(&argc, argv);
706    GraphicsComposerHidlEnvironment::Instance()->init(&argc, argv);
707    int status = RUN_ALL_TESTS();
708    ALOGI("Test result = %d", status);
709    return status;
710}
711