Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 07e54e4a authored by sergiuferentz's avatar sergiuferentz
Browse files

Removing tests used to ensure the transition from HIDL to AIDL works 

File no longer needed so let's remove bloat.

Test: Build
Bug: 304520517

Change-Id: I23750b4afe3c2b36c261d226b26f50ce858fa235
parent cc89e85f

services/surfaceflinger/tests/Android.bp

+0 −1
Original line number Original line Diff line number Diff line
@@ -32,7 +32,6 @@ cc_test { 
        "BootDisplayMode_test.cpp",

        "BootDisplayMode_test.cpp",

        "Binder_test.cpp",

        "Binder_test.cpp",

        "BufferGenerator.cpp",

        "BufferGenerator.cpp",

        "CommonTypes_test.cpp",

        "Credentials_test.cpp",

        "Credentials_test.cpp",

        "DereferenceSurfaceControl_test.cpp",

        "DereferenceSurfaceControl_test.cpp",

        "DisplayConfigs_test.cpp",

        "DisplayConfigs_test.cpp",

services/surfaceflinger/tests/CommonTypes_test.cpp

deleted100644 → 0
+0 −200
Original line number Original line Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <aidl/android/hardware/graphics/common/BlendMode.h>

#include <aidl/android/hardware/graphics/common/Dataspace.h>



#include <android/data_space.h>

#include <android/hardware/graphics/common/1.2/types.h>

#include <android/hardware/graphics/composer/2.1/IComposerClient.h>



using AidlBlendMode = aidl::android::hardware::graphics::common::BlendMode;

using AidlDataspace = aidl::android::hardware::graphics::common::Dataspace;



using HidlBlendMode = android::hardware::graphics::composer::V2_1::IComposerClient::BlendMode;

using HidlDataspace = android::hardware::graphics::common::V1_2::Dataspace;



static_assert(static_cast<uint32_t>(AidlBlendMode::INVALID) ==

              static_cast<uint32_t>(HidlBlendMode::INVALID));

static_assert(static_cast<uint32_t>(AidlBlendMode::NONE) ==

              static_cast<uint32_t>(HidlBlendMode::NONE));

static_assert(static_cast<uint32_t>(AidlBlendMode::PREMULTIPLIED) ==

              static_cast<uint32_t>(HidlBlendMode::PREMULTIPLIED));

static_assert(static_cast<uint32_t>(AidlBlendMode::COVERAGE) ==

              static_cast<uint32_t>(HidlBlendMode::COVERAGE));



static_assert(static_cast<uint32_t>(ADATASPACE_UNKNOWN) ==

              static_cast<uint32_t>(AidlDataspace::UNKNOWN));

static_assert(static_cast<uint32_t>(ADATASPACE_SCRGB_LINEAR) ==

              static_cast<uint32_t>(AidlDataspace::SCRGB_LINEAR));

static_assert(static_cast<uint32_t>(ADATASPACE_SRGB) == static_cast<uint32_t>(AidlDataspace::SRGB));

static_assert(static_cast<uint32_t>(ADATASPACE_SCRGB) ==

              static_cast<uint32_t>(AidlDataspace::SCRGB));

static_assert(static_cast<uint32_t>(ADATASPACE_DISPLAY_P3) ==

              static_cast<uint32_t>(AidlDataspace::DISPLAY_P3));

static_assert(static_cast<uint32_t>(ADATASPACE_BT2020_PQ) ==

              static_cast<uint32_t>(AidlDataspace::BT2020_PQ));

static_assert(static_cast<uint32_t>(ADATASPACE_ADOBE_RGB) ==

              static_cast<uint32_t>(AidlDataspace::ADOBE_RGB));

static_assert(static_cast<uint32_t>(ADATASPACE_BT2020) ==

              static_cast<uint32_t>(AidlDataspace::BT2020));

static_assert(static_cast<uint32_t>(ADATASPACE_BT709) ==

              static_cast<uint32_t>(AidlDataspace::BT709));

static_assert(static_cast<uint32_t>(ADATASPACE_DCI_P3) ==

              static_cast<uint32_t>(AidlDataspace::DCI_P3));

static_assert(static_cast<uint32_t>(ADATASPACE_SRGB_LINEAR) ==

              static_cast<uint32_t>(AidlDataspace::SRGB_LINEAR));



static_assert(static_cast<uint32_t>(ADATASPACE_UNKNOWN) ==

              static_cast<uint32_t>(HidlDataspace::UNKNOWN));

static_assert(static_cast<uint32_t>(ADATASPACE_SCRGB_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::V0_SCRGB_LINEAR));

static_assert(static_cast<uint32_t>(ADATASPACE_SRGB) ==

              static_cast<uint32_t>(HidlDataspace::V0_SRGB));

static_assert(static_cast<uint32_t>(ADATASPACE_SCRGB) ==

              static_cast<uint32_t>(HidlDataspace::V0_SCRGB));

static_assert(static_cast<uint32_t>(ADATASPACE_DISPLAY_P3) ==

              static_cast<uint32_t>(HidlDataspace::DISPLAY_P3));

static_assert(static_cast<uint32_t>(ADATASPACE_BT2020_PQ) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_PQ));

static_assert(static_cast<uint32_t>(ADATASPACE_ADOBE_RGB) ==

              static_cast<uint32_t>(HidlDataspace::ADOBE_RGB));

static_assert(static_cast<uint32_t>(ADATASPACE_BT2020) ==

              static_cast<uint32_t>(HidlDataspace::BT2020));

static_assert(static_cast<uint32_t>(ADATASPACE_BT709) ==

              static_cast<uint32_t>(HidlDataspace::V0_BT709));

static_assert(static_cast<uint32_t>(ADATASPACE_DCI_P3) ==

              static_cast<uint32_t>(HidlDataspace::DCI_P3));

static_assert(static_cast<uint32_t>(ADATASPACE_SRGB_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::V0_SRGB_LINEAR));



static_assert(static_cast<uint32_t>(AidlDataspace::UNKNOWN) ==

              static_cast<uint32_t>(HidlDataspace::UNKNOWN));

static_assert(static_cast<uint32_t>(AidlDataspace::ARBITRARY) ==

              static_cast<uint32_t>(HidlDataspace::ARBITRARY));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_SHIFT) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_SHIFT));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_MASK) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_MASK));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_UNSPECIFIED) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_UNSPECIFIED));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT709) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT709));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_625) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_625));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_625_UNADJUSTED) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_625_UNADJUSTED));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_525) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_525));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_525_UNADJUSTED) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_525_UNADJUSTED));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT2020) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT2020));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT2020_CONSTANT_LUMINANCE) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT2020_CONSTANT_LUMINANCE));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT470M) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT470M));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_FILM) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_FILM));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_DCI_P3) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_DCI_P3));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_ADOBE_RGB) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_ADOBE_RGB));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_SHIFT) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_SHIFT));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_MASK) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_MASK));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_UNSPECIFIED) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_UNSPECIFIED));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_SRGB) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_SRGB));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_SMPTE_170M) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_SMPTE_170M));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_GAMMA2_2) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_GAMMA2_2));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_GAMMA2_6) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_GAMMA2_6));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_GAMMA2_8) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_GAMMA2_8));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_ST2084) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_ST2084));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_HLG) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_HLG));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_SHIFT) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_SHIFT));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_MASK) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_MASK));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_UNSPECIFIED) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_UNSPECIFIED));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_FULL) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_FULL));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_LIMITED) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_LIMITED));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_EXTENDED) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_EXTENDED));

static_assert(static_cast<uint32_t>(AidlDataspace::SRGB_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::V0_SRGB_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::SCRGB_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::V0_SCRGB_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::SRGB) ==

              static_cast<uint32_t>(HidlDataspace::V0_SRGB));

static_assert(static_cast<uint32_t>(AidlDataspace::SCRGB) ==

              static_cast<uint32_t>(HidlDataspace::V0_SCRGB));

static_assert(static_cast<uint32_t>(AidlDataspace::JFIF) ==

              static_cast<uint32_t>(HidlDataspace::V0_JFIF));

static_assert(static_cast<uint32_t>(AidlDataspace::BT601_625) ==

              static_cast<uint32_t>(HidlDataspace::V0_BT601_625));

static_assert(static_cast<uint32_t>(AidlDataspace::BT601_525) ==

              static_cast<uint32_t>(HidlDataspace::V0_BT601_525));

static_assert(static_cast<uint32_t>(AidlDataspace::BT709) ==

              static_cast<uint32_t>(HidlDataspace::V0_BT709));

static_assert(static_cast<uint32_t>(AidlDataspace::DCI_P3_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::DCI_P3_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::DCI_P3) ==

              static_cast<uint32_t>(HidlDataspace::DCI_P3));

static_assert(static_cast<uint32_t>(AidlDataspace::DISPLAY_P3_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::DISPLAY_P3_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::DISPLAY_P3) ==

              static_cast<uint32_t>(HidlDataspace::DISPLAY_P3));

static_assert(static_cast<uint32_t>(AidlDataspace::ADOBE_RGB) ==

              static_cast<uint32_t>(HidlDataspace::ADOBE_RGB));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020) ==

              static_cast<uint32_t>(HidlDataspace::BT2020));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_PQ) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_PQ));

static_assert(static_cast<uint32_t>(AidlDataspace::DEPTH) ==

              static_cast<uint32_t>(HidlDataspace::DEPTH));

static_assert(static_cast<uint32_t>(AidlDataspace::SENSOR) ==

              static_cast<uint32_t>(HidlDataspace::SENSOR));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_ITU) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_ITU));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_ITU_PQ) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_ITU_PQ));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_ITU_HLG) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_ITU_HLG));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_HLG) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_HLG));

static_assert(static_cast<uint32_t>(AidlDataspace::DISPLAY_BT2020) ==

              static_cast<uint32_t>(HidlDataspace::DISPLAY_BT2020));

static_assert(static_cast<uint32_t>(AidlDataspace::DYNAMIC_DEPTH) ==

              static_cast<uint32_t>(HidlDataspace::DYNAMIC_DEPTH));

static_assert(static_cast<uint32_t>(AidlDataspace::JPEG_APP_SEGMENTS) ==

              static_cast<uint32_t>(HidlDataspace::JPEG_APP_SEGMENTS));

static_assert(static_cast<uint32_t>(AidlDataspace::HEIF) ==

              static_cast<uint32_t>(HidlDataspace::HEIF));