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

Commit 3559eb0e authored by Robert Shih's avatar Robert Shih
Browse files

drm: add 1.3 vts 

Bug: 139313724
Bug: 139134043
Change-Id: I54af955790e76dc364e7ff9f9d6984d9b6abbb68
parent 2801b037

drm/1.3/vts/OWNERS

0 → 100644
+9 −0
Original line number Diff line number Diff line 
conglin@google.com

edwinwong@google.com

fredgc@google.com

jtinker@google.com

juce@google.com

kylealexander@google.com

rfrias@google.com

robertshih@google.com

sigquit@google.com

drm/1.3/vts/functional/Android.bp

0 → 100644
+78 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2020 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.

//



cc_library_static {

    name: "android.hardware.drm@1.3-vts",

    defaults: ["VtsHalTargetTestDefaults"],

    local_include_dirs: [

        "include",

    ],

    srcs: [

        "drm_hal_test.cpp",

    ],

    shared_libs: [

        "android.hardware.drm@1.0",

        "android.hardware.drm@1.1",

        "android.hardware.drm@1.2",

        "android.hardware.drm@1.3",

        "android.hidl.allocator@1.0",

        "android.hidl.memory@1.0",

        "libhidlmemory",

        "libnativehelper",

    ],

    static_libs: [

        "android.hardware.drm@1.0-helper",

        "libcrypto_static",

        "libdrmvtshelper",

    ],

    export_include_dirs: [

        "include",

    ],

}



cc_test {

    name: "VtsHalDrmV1_3TargetTest",

    defaults: ["VtsHalTargetTestDefaults"],

    include_dirs: ["hardware/interfaces/drm/1.0/vts/functional"],

    srcs: [

        "drm_hal_test_main.cpp",

    ],

    whole_static_libs: [

        "android.hardware.drm@1.0-vts",

        "android.hardware.drm@1.1-vts",

        "android.hardware.drm@1.2-vts",

        "android.hardware.drm@1.3-vts",

    ],

    shared_libs: [

        "android.hardware.drm@1.0",

        "android.hardware.drm@1.1",

        "android.hardware.drm@1.2",

        "android.hardware.drm@1.3",

        "android.hidl.allocator@1.0",

        "android.hidl.memory@1.0",

        "libhidlmemory",

        "libnativehelper",

    ],

    static_libs: [

        "android.hardware.drm@1.0-helper",

        "libcrypto_static",

        "libdrmvtshelper",

    ],

    test_suites: [

        "general-tests",

        "vts-core",

    ],

}

drm/1.3/vts/functional/drm_hal_test.cpp

0 → 100644
+60 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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.

 */



#define LOG_TAG "drm_hal_test@1.3"



#include "android/hardware/drm/1.3/vts/drm_hal_test.h"



namespace android {

namespace hardware {

namespace drm {

namespace V1_3 {

namespace vts {



TEST_P(DrmHalTestV1_3, SchemeSupported) {

    EXPECT_TRUE(drmFactory_->isCryptoSchemeSupported(GetParam().scheme_));

}



TEST_P(DrmHalTestV1_3, SignRsaNotAllowed) {

    hidl_array<uint8_t, 16> kWidevineUUID ({

        0xED,0xEF,0x8B,0xA9,0x79,0xD6,0x4A,0xCE,

        0xA3,0xC8,0x27,0xDC,0xD5,0x1D,0x21,0xED

    });



    if (!drmFactory_->isCryptoSchemeSupported(kWidevineUUID)) {

        GTEST_SKIP() << "Widevine only test";

    }



    // signRSA

    const hidl_vec<uint8_t>& sessionId{};

    const hidl_string& algorithm{};

    const hidl_vec<uint8_t>& message{};

    const hidl_vec<uint8_t>& wrappedKey{};

    auto res = drmPlugin_->signRSA(

        sessionId, algorithm, message, wrappedKey,

        [&](StatusV1_0 status, const hidl_vec<uint8_t>& signature) {

            EXPECT_EQ(status, StatusV1_0::ERROR_DRM_UNKNOWN);

            EXPECT_EQ(signature.size(), 0);

        }

    );

    EXPECT_TRUE(res.isOk());

}



}  // namespace vts

}  // namespace V1_3

}  // namespace drm

}  // namespace hardware

}  // namespace android

drm/1.3/vts/functional/drm_hal_test_main.cpp

0 → 100644
+134 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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.

 */



/**

 * Instantiate the set of test cases for each vendor module

 */



#define LOG_TAG "drm_hal_test@1.3"



#include <android/hardware/drm/1.3/ICryptoFactory.h>

#include <android/hardware/drm/1.3/IDrmFactory.h>

#include <gtest/gtest.h>

#include <hidl/HidlSupport.h>

#include <hidl/ServiceManagement.h>

#include <log/log.h>



#include <algorithm>

#include <iterator>

#include <string>

#include <utility>

#include <vector>



#include "android/hardware/drm/1.0/vts/drm_hal_clearkey_test.h" // V1_0 tests

#include "android/hardware/drm/1.0/vts/drm_hal_vendor_test.h"   // V1_0 tests

#include "android/hardware/drm/1.1/vts/drm_hal_clearkey_test.h" // V1_1 tests

#include "android/hardware/drm/1.2/vts/drm_hal_common.h"        // V1_2 tests

#include "android/hardware/drm/1.3/vts/drm_hal_test.h"          // V1_3 tests



using drm_vts::DrmHalTestParam;

using drm_vts::PrintParamInstanceToString;



using android::hardware::drm::V1_0::vts::DrmHalVendorFactoryTest;

using android::hardware::drm::V1_0::vts::DrmHalVendorPluginTest;

using android::hardware::drm::V1_0::vts::DrmHalVendorDecryptTest;

using android::hardware::drm::V1_0::vts::DrmHalClearkeyFactoryTest;

using android::hardware::drm::V1_0::vts::DrmHalClearkeyPluginTest;

using android::hardware::drm::V1_0::vts::DrmHalClearkeyDecryptTest;

using android::hardware::drm::V1_1::vts::DrmHalClearkeyTest;

using android::hardware::drm::V1_2::vts::DrmHalTest;

using android::hardware::drm::V1_2::vts::DrmHalClearkeyTestV1_2;

using android::hardware::drm::V1_3::vts::DrmHalTestV1_3;



static const std::vector<DrmHalTestParam> kAllInstances = [] {

    using ::android::hardware::drm::V1_3::ICryptoFactory;

    using ::android::hardware::drm::V1_3::IDrmFactory;



    std::vector<std::string> drmInstances =

            android::hardware::getAllHalInstanceNames(IDrmFactory::descriptor);

    std::vector<std::string> cryptoInstances =

            android::hardware::getAllHalInstanceNames(ICryptoFactory::descriptor);

    std::set<std::string> allInstances;

    allInstances.insert(drmInstances.begin(), drmInstances.end());

    allInstances.insert(cryptoInstances.begin(), cryptoInstances.end());



    std::vector<DrmHalTestParam> allInstanceUuidCombos;

    for (const auto &instance : allInstances) {

        auto drmFactory = IDrmFactory::getService(instance);

        if (drmFactory == nullptr) {

            continue;

        }

        drmFactory->getSupportedCryptoSchemes(

            [&](const hidl_vec<hidl_array<uint8_t, 16>>& schemes) {

                for (const auto &scheme : schemes) {

                    allInstanceUuidCombos.push_back(DrmHalTestParam(instance, scheme));

                }

            });

    }

    return allInstanceUuidCombos;

}();



INSTANTIATE_TEST_CASE_P(PerInstanceUuidV1_0, DrmHalVendorFactoryTest,

                        testing::ValuesIn(kAllInstances),

                        drm_vts::PrintParamInstanceToString);

INSTANTIATE_TEST_CASE_P(PerInstanceUuidV1_0, DrmHalVendorPluginTest,

                        testing::ValuesIn(kAllInstances),

                        drm_vts::PrintParamInstanceToString);

INSTANTIATE_TEST_CASE_P(PerInstanceUuidV1_0, DrmHalVendorDecryptTest,

                        testing::ValuesIn(kAllInstances),

                        drm_vts::PrintParamInstanceToString);



INSTANTIATE_TEST_SUITE_P(PerInstanceUuidV1_0, DrmHalClearkeyFactoryTest,

                         testing::ValuesIn(kAllInstances),

                         drm_vts::PrintParamInstanceToString);

INSTANTIATE_TEST_SUITE_P(PerInstanceUuidV1_0, DrmHalClearkeyPluginTest,

                         testing::ValuesIn(kAllInstances),

                         drm_vts::PrintParamInstanceToString);

INSTANTIATE_TEST_SUITE_P(PerInstanceUuidV1_0, DrmHalClearkeyDecryptTest,

                         testing::ValuesIn(kAllInstances),

                         drm_vts::PrintParamInstanceToString);



INSTANTIATE_TEST_SUITE_P(PerInstanceUuidV1_1, DrmHalClearkeyTest,

                         testing::ValuesIn(kAllInstances),

                         PrintParamInstanceToString);



INSTANTIATE_TEST_SUITE_P(PerInstanceUuidV1_2, DrmHalTest,

                         testing::ValuesIn(kAllInstances),

                         PrintParamInstanceToString);

INSTANTIATE_TEST_SUITE_P(PerInstanceUuidV1_2, DrmHalClearkeyTestV1_2,

                         testing::ValuesIn(kAllInstances),

                         PrintParamInstanceToString);



INSTANTIATE_TEST_SUITE_P(PerInstanceUuidV1_3, DrmHalTestV1_3,

                         testing::ValuesIn(kAllInstances),

                         PrintParamInstanceToString);



int main(int argc, char** argv) {

#if defined(__LP64__)

    const char* kModulePath = "/data/local/tmp/64/lib";

#else

    const char* kModulePath = "/data/local/tmp/32/lib";

#endif

    DrmHalTest::gVendorModules = new drm_vts::VendorModules(kModulePath);

    if (DrmHalTest::gVendorModules->getPathList().size() == 0) {

        std::cerr << "WARNING: No vendor modules found in " << kModulePath <<

                ", all vendor tests will be skipped" << std::endl;

    }

    ::testing::InitGoogleTest(&argc, argv);

    int status = RUN_ALL_TESTS();

    ALOGI("Test result = %d", status);

    return status;

}

drm/1.3/vts/functional/include/android/hardware/drm/1.3/vts/drm_hal_test.h

0 → 100644
+86 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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.

 */



#ifndef DRM_HAL_TEST_V1_3_H

#define DRM_HAL_TEST_V1_3_H



#include <android/hardware/drm/1.3/ICryptoFactory.h>

#include <android/hardware/drm/1.3/IDrmFactory.h>

#include <gtest/gtest.h>

#include <hidl/HidlSupport.h>

#include <hidl/ServiceManagement.h>

#include <log/log.h>



#include <algorithm>

#include <iterator>

#include <string>

#include <utility>

#include <vector>



#include "drm_hal_vendor_module_api.h"

#include "drm_vts_helper.h"

#include "vendor_modules.h"

#include "VtsHalHidlTargetCallbackBase.h"



namespace android {

namespace hardware {

namespace drm {

namespace V1_3 {

namespace vts {



using android::hardware::hidl_array;

using android::hardware::hidl_string;



using drm_vts::DrmHalTestParam;



using IDrmFactoryV1_3 = android::hardware::drm::V1_3::IDrmFactory;

using IDrmPluginV1_0 = android::hardware::drm::V1_0::IDrmPlugin;

using StatusV1_0 = android::hardware::drm::V1_0::Status;



class DrmHalTestV1_3 : public ::testing::TestWithParam<DrmHalTestParam> {

public:

    DrmHalTestV1_3()

        : drmFactory_(IDrmFactoryV1_3::getService(GetParam().instance_)) {}



    virtual void SetUp() override {

        ASSERT_NE(drmFactory_, nullptr);



        // create plugin

        hidl_string packageName("android.hardware.drm.V1_3.vts");

        auto res = drmFactory_->createPlugin(

            GetParam().scheme_, packageName,

            [&](StatusV1_0 status, const sp<IDrmPluginV1_0>& pluginV1_0) {

                EXPECT_EQ(StatusV1_0::OK, status);

                drmPlugin_ = pluginV1_0;

            });

        EXPECT_TRUE(res.isOk());

        ASSERT_NE(drmPlugin_, nullptr);

    }



    virtual void TearDown() override {}



protected:

    sp<IDrmFactoryV1_3> drmFactory_;

    sp<IDrmPluginV1_0> drmPlugin_;

};



}  // namespace vts

}  // namespace V1_3

}  // namespace drm

}  // namespace hardware

}  // namespace android



#endif  // DRM_HAL_TEST_V1_3_H