From 4ad333e6d425ffe08f00358b19ae0c5d19d313e8 Mon Sep 17 00:00:00 2001 From: zpf Date: Wed, 3 Sep 2025 20:16:25 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E5=91=8A=E8=AD=A6=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zpf --- .../c/drm_capi/native_mediakeysystem.cpp | 1236 +-- .../unittest/src/drm_framework_unittest.cpp | 7929 +++++++++-------- services/utils/include/drm_common_utils.h | 35 + 3 files changed, 4634 insertions(+), 4566 deletions(-) create mode 100644 services/utils/include/drm_common_utils.h diff --git a/frameworks/c/drm_capi/native_mediakeysystem.cpp b/frameworks/c/drm_capi/native_mediakeysystem.cpp index 347a74b..9c9cc69 100644 --- a/frameworks/c/drm_capi/native_mediakeysystem.cpp +++ b/frameworks/c/drm_capi/native_mediakeysystem.cpp @@ -1,616 +1,620 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * 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 -#include -#include -#include -#include -#include -#include "drm_log.h" -#include "drm_trace.h" -#include "native_drm_common.h" -#include "native_drm_base.h" -#include "native_drm_object.h" -#include "native_mediakeysystem.h" -#include "drm_api_operation.h" -#include "media_key_system_factory_impl.h" -#include "drm_error_code.h" - -using namespace OHOS::DrmStandard; - -bool OH_MediaKeySystem_IsSupported(const char *uuid) -{ - DRM_INFO_LOG("OH_MediaKeySystem_IsSupported enter."); - DRM_CHECK_AND_RETURN_RET_LOG(uuid != nullptr, false, "MediaKeySystem uuid is nullptr!"); - std::string uuidPtr(uuid); - bool isSupported = false; - DRM_CHECK_AND_RETURN_RET_LOG(uuidPtr.size() != 0, false, "MediaKeySystem uuidPtr.size is nullptr!"); - OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); - isSupported = fatory->IsMediaKeySystemSupported(uuidPtr); - return isSupported; -} - -bool OH_MediaKeySystem_IsSupported2(const char *uuid, const char *mimeType) -{ - DRM_INFO_LOG("OH_MediaKeySystem_IsSupported2 enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((uuid != nullptr) && (mimeType != nullptr)), false, - "OH_MediaKeySystem_IsSupported2 uuid is nullptr!"); - bool isSupported = false; - std::string uuidPtr(uuid); - DRM_CHECK_AND_RETURN_RET_LOG(uuidPtr.size() != 0, false, "MediaKeySystem uuidPtr.size is nullptr!"); - std::string mimeTypePtr = std::string(mimeType); - DRM_CHECK_AND_RETURN_RET_LOG(mimeTypePtr.size() != 0, false, "MediaKeySystem mimeTypePtr.size is nullptr!"); - - OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); - isSupported = fatory->IsMediaKeySystemSupported(uuidPtr, mimeTypePtr); - return isSupported; -} - -bool OH_MediaKeySystem_IsSupported3(const char *uuid, const char *mimeType, - DRM_ContentProtectionLevel ContentProtectionLevel) -{ - DRM_INFO_LOG("OH_MediaKeySystem_IsSupported3 enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((uuid != nullptr) && (mimeType != nullptr)), false, - "OH_MediaKeySystem_IsSupported3 uuid is nullptr!"); - bool isSupported = false; - std::string uuidPtr(uuid); - DRM_CHECK_AND_RETURN_RET_LOG(uuidPtr.size() != 0, false, "MediaKeySystem Uuid.size is nullptr!"); - std::string mimeTypePtr = std::string(mimeType); - DRM_CHECK_AND_RETURN_RET_LOG(mimeTypePtr.size() != 0, false, "MediaKeySystem mimeTypePtr.size is nullptr!"); - - OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); - - OHOS::DrmStandard::ContentProtectionLevel securityLevel = - (OHOS::DrmStandard::ContentProtectionLevel)ContentProtectionLevel; - if ((securityLevel <= OHOS::DrmStandard::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN) || - (securityLevel >= OHOS::DrmStandard::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_MAX)) { - DRM_ERR_LOG("ContentProtectionLevel is invalid"); - return false; - } - isSupported = fatory->IsMediaKeySystemSupported(uuidPtr, mimeTypePtr, securityLevel); - return isSupported; -} - -Drm_ErrCode OH_MediaKeySystem_GetMediaKeySystems(DRM_MediaKeySystemDescription *description, uint32_t *count) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GetMediaKeySystems enter"); - DRM_CHECK_AND_RETURN_RET_LOG((description != nullptr), DRM_ERR_INVALID_VAL, "description is nullptr"); - DRM_CHECK_AND_RETURN_RET_LOG((count != nullptr), DRM_ERR_INVALID_VAL, "count is nullptr"); - std::map keySystemNames; - OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); - int32_t ret = fatory->GetMediaKeySystems(keySystemNames); - DRM_CHECK_AND_RETURN_RET_LOG((*count >= keySystemNames.size()), DRM_ERR_INVALID_VAL, - "GetMediaKeySystems failed because the count passed by is too small."); - int32_t times = 0; - DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_ERR_OK), DRM_ERR_UNKNOWN, - "GetMediaKeySystems call Failed!"); - for (auto it = keySystemNames.begin(); it != keySystemNames.end(); it++) { - if (it->first.size() != 0) { - ret = strcpy_s(description[times].name, sizeof(description[times].name) - 1, it->first.c_str()); - if (ret != 0) { - DRM_ERR_LOG("OH_MediaKeySystem_GetMediaKeySystems memcpy_s description faild!"); - return DRM_ERR_NO_MEMORY; - } - } - if (it->second.size() == (sizeof(description[times].uuid) * BASE_CONVERSION_OPERATOR)) { - for (size_t i = 0; i < sizeof(description[times].uuid) * BASE_CONVERSION_OPERATOR; - i += BASE_CONVERSION_OPERATOR) { - std::string byteStr = it->second.substr(i, BASE_CONVERSION_OPERATOR); - uint8_t byte = static_cast(std::stoi(byteStr, nullptr, HEXADECIMAL)); - description[times].uuid[i/BASE_CONVERSION_OPERATOR] = byte; - } - } - times++; - } - if (keySystemNames.size() == 0) { - DRM_ERR_LOG("plugin not exist."); - return DRM_ERR_UNKNOWN; - } - *count = keySystemNames.size(); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_Create(const char *name, MediaKeySystem **mediaKeySystem) -{ - DRM_INFO_LOG("OH_MediaKeySystem_Create enter."); - DrmTrace trace("OH_MediaKeySystem_Create"); - std::map errCodeMaps = { - {static_cast(DRM_INNER_ERR_INVALID_VAL), DRM_ERR_INVALID_VAL}, - {static_cast(DRM_INNER_ERR_SERVICE_FATAL_ERROR), DRM_ERR_SERVICE_DIED}, - {static_cast(DRM_INNER_ERR_MAX_SYSTEM_NUM_REACHED), DRM_ERR_MAX_SYSTEM_NUM_REACHED}, - {static_cast(DRM_INNER_ERR_UNKNOWN), DRM_ERR_UNKNOWN}, - {0, DRM_ERR_OK} - }; - DRM_CHECK_AND_RETURN_RET_LOG(((name != nullptr) && (mediaKeySystem != nullptr)), DRM_ERR_INVALID_VAL, - "parameter is error!"); - std::string nameStr = name; - DRM_CHECK_AND_RETURN_RET_LOG(nameStr.size() != 0, DRM_ERR_INVALID_VAL, "the size of nameStr is zero"); - - OHOS::sptr factory = MediaKeySystemFactoryImpl::GetInstance(); - DRM_CHECK_AND_RETURN_RET_LOG(factory != nullptr, DRM_ERR_UNKNOWN, "factory is nullptr!"); - OHOS::sptr system = nullptr; - int32_t result = factory->CreateMediaKeySystem(nameStr, &system); - Drm_ErrCode retCode = DRM_ERR_UNKNOWN; - if (errCodeMaps.find(result) != errCodeMaps.end()) { - retCode = errCodeMaps[result]; - } - DRM_CHECK_AND_RETURN_RET_LOG(system != nullptr, retCode, "system create by name failed!"); - - struct MediaKeySystemObject *object = new (std::nothrow) MediaKeySystemObject(system); - DRM_CHECK_AND_RETURN_RET_LOG(object != nullptr, DRM_ERR_UNKNOWN, "MediaKeySystemObject create failed!"); - - object->systemCallback_ = new (std::nothrow) MediaKeySystemCallbackCapi(); - if (object->systemCallback_ == nullptr) { - delete object; - DRM_ERR_LOG("MediaKeySystemObject create systemCallback failed!"); - return DRM_ERR_UNKNOWN; - } - int32_t ret = object->systemImpl_->SetCallback(object->systemCallback_); - if (ret != DRM_ERR_OK) { - delete object; - DRM_ERR_LOG("system set callback failed!"); - return DRM_ERR_UNKNOWN; - } - - *mediaKeySystem = object; - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_SetConfigurationString(MediaKeySystem *mediaKeySystem, const char *configName, - const char *value) -{ - DRM_INFO_LOG("OH_MediaKeySystem_SetConfigurationString enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_SetConfigurationString parameter is error!"); - - int32_t result = DRM_ERR_OK; - std::string name(configName); - DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetConfigurationString configName.size is not zero!"); - std::string valuePtr(value); - DRM_CHECK_AND_RETURN_RET_LOG(valuePtr.size() != 0, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetConfigurationString value.size is not zero!"); - - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetConfigurationString inner systemImpl is nullptr!"); - result = systemObject->systemImpl_->SetConfigurationString(name, valuePtr); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_SetConfigurationString mediaKeySystemImpl::SetConfigurationString faild!"); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_GetConfigurationString(MediaKeySystem *mediaKeySystem, const char *configName, - char *value, int32_t valueLen) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GetConfigurationString enter"); - DRM_CHECK_AND_RETURN_RET_LOG( - ((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen > 0)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetConfigurationString params is error!"); - - std::string valuePtr; - int32_t result = DRM_ERR_UNKNOWN; - std::string name = std::string(configName); - DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, - "configName.size is not zero!"); - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_GetConfigurationString faild!"); - result = systemObject->systemImpl_->GetConfigurationString(name, valuePtr); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "mediaKeySystemImpl::GetConfigurationString faild!"); - DRM_CHECK_AND_RETURN_RET_LOG(valueLen >= (int32_t)valuePtr.size(), DRM_ERR_INVALID_VAL, - "The space for value is too small"); - memset_s(value, valueLen, 0, valueLen); - int32_t ret = memcpy_s(value, valuePtr.size(), valuePtr.c_str(), valuePtr.size()); - if (ret != 0) { - DRM_ERR_LOG("OH_MediaKeySystem_GetConfigurationString memcpy_s value failed!"); - return DRM_ERR_NO_MEMORY; - } - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_SetConfigurationByteArray(MediaKeySystem *mediaKeySystem, - const char *configName, uint8_t *value, int32_t valueLen) - -{ - DRM_INFO_LOG("OH_MediaKeySystem_SetConfigurationByteArray enter."); - DRM_CHECK_AND_RETURN_RET_LOG( - ((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen > 0)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_SetConfigurationByteArray params is error!"); - - int32_t result = DRM_ERR_OK; - std::string name(configName); - DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetConfigurationByteArray configName.size is not zero!"); - uint8_t *valueDataPtr = reinterpret_cast(value); - DRM_CHECK_AND_RETURN_RET_LOG(valueDataPtr != nullptr, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetConfigurationByteArray value is nullptr!"); - std::vector valueptr(valueDataPtr, valueDataPtr + valueLen); - DRM_CHECK_AND_RETURN_RET_LOG(valueptr.size() != 0, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetConfigurationByteArray value.size is not zero!"); - - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::SetConfigurationByteArray faild!"); - result = systemObject->systemImpl_->SetConfigurationByteArray(name, valueptr); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_SetConfigurationByteArray mediaKeySystemImpl::SetConfigurationByteArray faild!"); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_GetConfigurationByteArray(MediaKeySystem *mediaKeySystem, - const char *configName, uint8_t *value, int32_t *valueLen) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GetConfigurationByteArray enter"); - DRM_CHECK_AND_RETURN_RET_LOG( - ((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen != nullptr)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetConfigurationByteArray parameter is error!"); - - std::vector valuePtr; - int32_t result = DRM_ERR_OK; - std::string name = std::string(configName); - DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, - "configName.size is not zero!"); - - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_GetConfigurationByteArray faild!"); - result = systemObject->systemImpl_->GetConfigurationByteArray(name, valuePtr); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "mediaKeySystemImpl::GetConfigurationByteArray faild!"); - DRM_CHECK_AND_RETURN_RET_LOG(*valueLen >= (int32_t)valuePtr.size(), DRM_ERR_INVALID_VAL, - "The space for value is too small!"); - *valueLen = valuePtr.size(); - int32_t ret = memcpy_s(value, valuePtr.size(), valuePtr.data(), valuePtr.size()); - if (ret != 0) { - DRM_ERR_LOG("OH_MediaKeySystem_GetConfigurationByteArray memcpy_s value faild!"); - return DRM_ERR_NO_MEMORY; - } - return DRM_ERR_OK; -} - -static Drm_ErrCode vectorToClist(std::vector &metrics, - DRM_Statistics *statistics) -{ - DRM_INFO_LOG("vectorToCArray start."); - memset_s(statistics, sizeof(DRM_Statistics), 0, sizeof(DRM_Statistics)); - statistics->statisticsCount = metrics.size(); - DRM_CHECK_AND_RETURN_RET_LOG((statistics->statisticsCount <= MAX_STATISTICS_COUNT), DRM_ERR_NO_MEMORY, - "statisticsCount err!"); - for (size_t i = 0; i < metrics.size(); i++) { - if (metrics[i].name.size() == 0 || metrics[i].name.size() > sizeof(statistics->statisticsName[i])) { - continue; - } - int32_t ret = memcpy_s(statistics->statisticsName[i], - sizeof(statistics->statisticsName[i]), metrics[i].name.c_str(), metrics[i].name.size()); - if (ret != 0) { - DRM_ERR_LOG(" memcpy_s faild!"); - return DRM_ERR_NO_MEMORY; - } - if (metrics[i].value.size() != 0) { - ret = memcpy_s(statistics->statisticsDescription[i], - sizeof(statistics->statisticsDescription[i]), metrics[i].value.c_str(), metrics[i].value.size()); - if (ret != 0) { - DRM_ERR_LOG(" memcpy_s faild!"); - return DRM_ERR_NO_MEMORY; - } - } - } - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_GetStatistics(MediaKeySystem *mediaKeySystem, DRM_Statistics *statistics) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GetStatistics enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (statistics != nullptr)), DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_GetStatistics params is error!"); - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - std::vector metrics; - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::GetStatistics inner systemImpl is nullptr!"); - int32_t result = systemObject->systemImpl_->GetStatistics(metrics); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_GetStatistics systemObject is nullptr!"); - Drm_ErrCode ret = vectorToClist(metrics, statistics); - DRM_CHECK_AND_RETURN_RET_LOG(statistics != nullptr, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_GetStatistics statistics obtained is nullptr!"); - return ret; -} - -Drm_ErrCode OH_MediaKeySystem_GetMaxContentProtectionLevel(MediaKeySystem *mediaKeySystem, - DRM_ContentProtectionLevel *contentProtectionLevel) -{ - DRM_INFO_LOG("GetMaxContentProtectionLevel enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (contentProtectionLevel != nullptr)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetMaxContentProtectionLevel parameter is error!"); - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::GetMaxContentProtectionLevel faild!"); - int32_t result = DRM_ERR_OK; - ContentProtectionLevel level = - ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN; - result = systemObject->systemImpl_->GetMaxContentProtectionLevel(&level); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_GetMaxContentProtectionLevel fail!"); - if (level <= ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN || - level >= ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_MAX) { - DRM_ERR_LOG("the level obtained is beyond reasonable range!"); - return DRM_ERR_UNKNOWN; - } - *contentProtectionLevel = static_cast(level); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_GenerateKeySystemRequest(MediaKeySystem *mediaKeySystem, uint8_t *request, - int32_t *requestLen, char *defaultUrl, int32_t defaultUrlLen) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GenerateKeySystemRequest enter"); - DrmTrace trace("OH_MediaKeySystem_GenerateKeySystemRequest"); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (request != nullptr) && (requestLen != nullptr) && - (*requestLen > 0) && (defaultUrl != nullptr) && (defaultUrlLen > 0)), - DRM_ERR_INVALID_VAL, "Incorrect parameters of OH_MediaKeySystem_GenerateKeySystemRequest!"); - std::vector requestData; - std::string defaultUrlData; - - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::GenerateKeySystemRequest faild!"); - int32_t result = systemObject->systemImpl_->GenerateKeySystemRequest(requestData, defaultUrlData); - DRM_CHECK_AND_RETURN_RET_LOG(((result == DRM_ERR_OK) && (requestData.size() != 0)), DRM_ERR_UNKNOWN, - "MediaKeySystemImpl GenerateKeySystemRequest failed!"); - int32_t ret = memcpy_s(request, *requestLen, requestData.data(), requestData.size()); - *requestLen = requestData.size(); - DRM_CHECK_AND_RETURN_RET_LOG(ret == 0, DRM_ERR_NO_MEMORY, - "OH_MediaKeySystem_GenerateKeySystemRequest memcpy_s request failed!"); - ret = memset_s(defaultUrl, defaultUrlLen, 0, defaultUrlLen); - DRM_CHECK_AND_RETURN_RET_LOG(ret == 0, DRM_ERR_NO_MEMORY, - "OH_MediaKeySystem_GenerateKeySystemRequest memset_s defaultUrl failed!"); - if (defaultUrlData.size() != 0) { - ret = memcpy_s(defaultUrl, defaultUrlLen, defaultUrlData.data(), defaultUrlData.size()); - DRM_CHECK_AND_RETURN_RET_LOG(ret == 0, DRM_ERR_NO_MEMORY, - "OH_MediaKeySystem_GenerateKeySystemRequest memcpy_s defaultUrl failed!"); - } - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_ProcessKeySystemResponse(MediaKeySystem *mediaKeySystem, - uint8_t *response, int32_t responseLen) -{ - DRM_INFO_LOG("OH_MediaKeySystem_ProcessKeySystemResponse enter."); - int64_t beginTime = std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()).count(); - DrmTrace trace("OH_MediaKeySystem_ProcessKeySystemResponse"); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (response != nullptr) && (responseLen > 0)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_ProcessKeySystemResponse parameter is error!"); - int32_t result = DRM_ERR_OK; - std::vector keySystemResponse(response, response + responseLen); - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::ProcessKeySystemResponse faild!"); - result = systemObject->systemImpl_->ProcessKeySystemResponse(keySystemResponse); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_ProcessKeySystemResponse systemObject is nullptr!"); - ConfigParser::WriteEndEvent(0, 0, std::string("OH_MediaKeySystem_ProcessKeySystemResponse"), beginTime); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_GetCertificateStatus(MediaKeySystem *mediaKeySystem, DRM_CertificateStatus *certStatus) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GetCertificateStatus enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (certStatus != nullptr)), DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_GetCertificateStatus parameter is error!"); - CertificateStatus CertStatus; - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::GetCertificateStatus faild!"); - int32_t result = systemObject->systemImpl_->GetCertificateStatus(&CertStatus); - if (result != DRM_ERR_OK) { - *certStatus = CERT_STATUS_UNAVAILABLE; - DRM_ERR_LOG("OH_MediaKeySystem_GetCertificateStatus faild!"); - return DRM_ERR_UNKNOWN; - } - *certStatus = (DRM_CertificateStatus)((int32_t)(CertStatus)); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_SetMediaKeySystemCallback(MediaKeySystem *mediaKeySystem, - MediaKeySystem_Callback callback) -{ - DRM_INFO_LOG("OH_MediaKeySystem_SetMediaKeySystemCallback enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (callback != nullptr)), DRM_ERR_INVALID_VAL, - "parameter is error!"); - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetMediaKeySystemCallback faild!"); - systemObject->systemCallback_->SetCallbackReference(callback); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_SetCallback(MediaKeySystem *mediaKeySystem, OH_MediaKeySystem_Callback callback) -{ - DRM_INFO_LOG("OH_MediaKeySystem_SetCallback enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (callback != nullptr)), DRM_ERR_INVALID_VAL, - "parameter is error!"); - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_SetCallback faild!"); - systemObject->systemCallback_->SetCallbackReference(mediaKeySystem, callback); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_CreateMediaKeySession(MediaKeySystem *mediaKeySystem, DRM_ContentProtectionLevel *level, - MediaKeySession **mediaKeySession) -{ - DRM_INFO_LOG("OH_MediaKeySystem_CreateMediaKeySession enter."); - DrmTrace trace("OH_MediaKeySystem_CreateMediaKeySession"); - std::map errCodeMaps = { - {static_cast(DRM_INNER_ERR_SERVICE_FATAL_ERROR), DRM_ERR_SERVICE_DIED}, - {static_cast(DRM_INNER_ERR_MAX_SESSION_NUM_REACHED), DRM_ERR_MAX_SESSION_NUM_REACHED}, - {static_cast(DRM_INNER_ERR_UNKNOWN), DRM_ERR_UNKNOWN}, - {0, DRM_ERR_OK} - }; - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (level != nullptr) && (mediaKeySession != nullptr) && - (*level > CONTENT_PROTECTION_LEVEL_UNKNOWN) && (*level < CONTENT_PROTECTION_LEVEL_MAX)), - DRM_ERR_INVALID_VAL, "mediaKeySystem is nullptr!"); - struct MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::CreateMediaKeySession faild!"); - int32_t secure = static_cast(*level); - ContentProtectionLevel secureLevel = - static_cast(secure); - OHOS::sptr keySessionImpl = nullptr; - int32_t ret = systemObject->systemImpl_->CreateMediaKeySession(secureLevel, &keySessionImpl); - Drm_ErrCode retCode = DRM_ERR_UNKNOWN; - if (errCodeMaps.find(ret) != errCodeMaps.end()) { - retCode = errCodeMaps[ret]; - } - DRM_CHECK_AND_RETURN_RET_LOG(ret == DRM_ERR_OK, retCode, "session create return failed!"); - DRM_CHECK_AND_RETURN_RET_LOG(keySessionImpl != nullptr, DRM_ERR_INVALID_VAL, "session create failed!"); - - struct MediaKeySessionObject *sessionObject = new (std::nothrow) MediaKeySessionObject(keySessionImpl); - DRM_CHECK_AND_RETURN_RET_LOG(sessionObject != nullptr, DRM_ERR_NO_MEMORY, "MediaKeySessionObject create failed!"); - - sessionObject->sessionCallback_ = new (std::nothrow) MediaKeySessionCallbackCapi(); - if (sessionObject->sessionCallback_ == nullptr) { - delete sessionObject; - DRM_ERR_LOG("MediaKeySessionObject create sessionCallback failed!"); - return DRM_ERR_NO_MEMORY; - } - ret = sessionObject->sessionImpl_->SetCallback(sessionObject->sessionCallback_); - if (ret != DRM_ERR_OK) { - delete sessionObject; - DRM_ERR_LOG("session set callback failed!"); - return DRM_ERR_UNKNOWN; - } - - *mediaKeySession = static_cast(sessionObject); - return DRM_ERR_OK; -} - -static Drm_ErrCode vectorToC2DArray(std::vector> licenseIds, - DRM_OfflineMediakeyIdArray *offlineMediaKeyIds) -{ - DRM_INFO_LOG("vectorToC2DArray enter."); - if (licenseIds.size() >= MAX_OFFLINE_MEDIA_KEY_ID_COUNT) { - DRM_ERR_LOG("licenseIds size too large!"); - return DRM_ERR_NO_MEMORY; - } - - offlineMediaKeyIds->idsCount = (uint32_t)(licenseIds.size()); - for (size_t i = 0; i < licenseIds.size(); i++) { - if (licenseIds[i].size() != 0) { - offlineMediaKeyIds->idsLen[i] = (int32_t)(licenseIds[i].size()); - int32_t ret = memcpy_s(offlineMediaKeyIds->ids[i], MAX_OFFLINE_MEDIA_KEY_ID_LEN, licenseIds[i].data(), - licenseIds[i].size()); - if (ret != 0) { - DRM_ERR_LOG("memcpy_s faild!"); - return DRM_ERR_NO_MEMORY; - } - } - } - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_GetOfflineMediaKeyIds(MediaKeySystem *mediaKeySystem, - DRM_OfflineMediakeyIdArray *offlineMediaKeyIds) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GetOfflineMediaKeyIds enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyIds != nullptr)), DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_GetOfflineMediaKeyIds parameter is error!"); - std::vector> licenseIds; - - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::GetOfflineMediaKeyIds faild!"); - int32_t result = systemObject->systemImpl_->GetOfflineMediaKeyIds(licenseIds); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_GetOfflineMediaKeyIds faild!"); - if (licenseIds.size() == 0) { - DRM_DEBUG_LOG("licenseIds.data() is nullptr!"); - return DRM_ERR_OK; - } - result = vectorToC2DArray(licenseIds, offlineMediaKeyIds); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_NO_MEMORY, - "vectorToC2DArray faild!"); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_GetOfflineMediaKeyStatus(MediaKeySystem *mediaKeySystem, - uint8_t *offlineMediaKeyId, int32_t offlineMediaKeyIdLen, DRM_OfflineMediaKeyStatus *status) -{ - DRM_INFO_LOG("OH_MediaKeySystem_GetOfflineMediaKeyStatus enter"); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyId != nullptr) && - (offlineMediaKeyIdLen > 0) && (offlineMediaKeyIdLen <= MAX_OFFLINE_MEDIA_KEY_ID_LEN) && (status != nullptr)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetOfflineMediaKeyStatus parameter is error!"); - int32_t result = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - - std::vector licenseIdVec(offlineMediaKeyId, offlineMediaKeyId + offlineMediaKeyIdLen); - OfflineMediaKeyStatus offlineMediaKeyStatus = - OfflineMediaKeyStatus::OFFLINELICENSESTATUS_UNKNOWN; - - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::GetOfflineMediaKeyStatus faild!"); - result = systemObject->systemImpl_->GetOfflineMediaKeyStatus(licenseIdVec, offlineMediaKeyStatus); - if (result != DRM_ERR_OK) { - DRM_ERR_LOG("OH_MediaKeySystem_GetOfflineMediaKeyStatus faild!"); - return DRM_ERR_UNKNOWN; - } - DRM_OfflineMediaKeyStatus CofflineMediaKeyStatus = (DRM_OfflineMediaKeyStatus)((int32_t)(offlineMediaKeyStatus)); - if (CofflineMediaKeyStatus < OFFLINE_MEDIA_KEY_STATUS_UNKNOWN || - CofflineMediaKeyStatus > OFFLINE_MEDIA_KEY_STATUS_INACTIVE) { - DRM_ERR_LOG("OH_MediaKeySystem_GetOfflineMediaKeyStatus faild!"); - return DRM_ERR_UNKNOWN; - } - *status = CofflineMediaKeyStatus; - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_ClearOfflineMediaKeys(MediaKeySystem *mediaKeySystem, - uint8_t *offlineMediaKeyId, int32_t offlineMediaKeyIdLen) -{ - DRM_INFO_LOG("OH_MediaKeySystem_ClearOfflineMediaKeys enter."); - DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyId != nullptr) && - (offlineMediaKeyIdLen > 0) && (offlineMediaKeyIdLen <= MAX_OFFLINE_MEDIA_KEY_ID_LEN)), - DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_ClearOfflineMediaKeys parameter is error!"); - int32_t result = DRM_ERR_OK; - std::vector licenseIdVec(offlineMediaKeyId, offlineMediaKeyId + offlineMediaKeyIdLen); - DRM_CHECK_AND_RETURN_RET_LOG(licenseIdVec.size() != 0, DRM_ERR_INVALID_VAL, - "OH_MediaKeySystem_ClearOfflineMediaKeys configName.size is not zero!"); - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::OH_MediaKeySystem_ClearOfflineMediaKeys inner systemImpl is nullptr!"); - result = systemObject->systemImpl_->ClearOfflineMediaKeys(licenseIdVec); - DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, - "OH_MediaKeySystem_ClearOfflineMediaKeys mediaKeySystemImpl::ClearOfflineMediaKeys faild!"); - return DRM_ERR_OK; -} - -Drm_ErrCode OH_MediaKeySystem_Destroy(MediaKeySystem *mediaKeySystem) -{ - DRM_INFO_LOG("OH_MediaKeySystem_Destroy enter."); - DRM_CHECK_AND_RETURN_RET_LOG(mediaKeySystem != nullptr, DRM_ERR_INVALID_VAL, "mediaKeySystem is nullptr!"); - - struct MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "mediaKeySystemImpl::OH_MediaKeySystem_Destroy faild!"); - int32_t ret = systemObject->systemImpl_->Release(); - DRM_CHECK_AND_RETURN_RET_LOG(ret == DRM_ERR_OK, DRM_ERR_UNKNOWN, "call media key system release failed!"); - delete mediaKeySystem; - mediaKeySystem = nullptr; - return DRM_ERR_OK; -} +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * 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 +#include +#include +#include +#include +#include +#include "drm_log.h" +#include "drm_trace.h" +#include "native_drm_common.h" +#include "native_drm_base.h" +#include "native_drm_object.h" +#include "native_mediakeysystem.h" +#include "drm_api_operation.h" +#include "media_key_system_factory_impl.h" +#include "drm_error_code.h" +#include "drm_common_utils.h" + +using namespace OHOS::DrmStandard; + +bool OH_MediaKeySystem_IsSupported(const char *uuid) +{ + DRM_INFO_LOG("OH_MediaKeySystem_IsSupported enter."); + DRM_CHECK_AND_RETURN_RET_LOG(uuid != nullptr, false, "MediaKeySystem uuid is nullptr!"); + std::string uuidPtr(uuid); + bool isSupported = false; + DRM_CHECK_AND_RETURN_RET_LOG(uuidPtr.size() != 0, false, "MediaKeySystem uuidPtr.size is nullptr!"); + OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); + isSupported = fatory->IsMediaKeySystemSupported(uuidPtr); + return isSupported; +} + +bool OH_MediaKeySystem_IsSupported2(const char *uuid, const char *mimeType) +{ + DRM_INFO_LOG("OH_MediaKeySystem_IsSupported2 enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((uuid != nullptr) && (mimeType != nullptr)), false, + "OH_MediaKeySystem_IsSupported2 uuid is nullptr!"); + bool isSupported = false; + std::string uuidPtr(uuid); + DRM_CHECK_AND_RETURN_RET_LOG(uuidPtr.size() != 0, false, "MediaKeySystem uuidPtr.size is nullptr!"); + std::string mimeTypePtr = std::string(mimeType); + DRM_CHECK_AND_RETURN_RET_LOG(mimeTypePtr.size() != 0, false, "MediaKeySystem mimeTypePtr.size is nullptr!"); + + OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); + isSupported = fatory->IsMediaKeySystemSupported(uuidPtr, mimeTypePtr); + return isSupported; +} + +bool OH_MediaKeySystem_IsSupported3(const char *uuid, const char *mimeType, + DRM_ContentProtectionLevel ContentProtectionLevel) +{ + DRM_INFO_LOG("OH_MediaKeySystem_IsSupported3 enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((uuid != nullptr) && (mimeType != nullptr)), false, + "OH_MediaKeySystem_IsSupported3 uuid is nullptr!"); + bool isSupported = false; + std::string uuidPtr(uuid); + DRM_CHECK_AND_RETURN_RET_LOG(uuidPtr.size() != 0, false, "MediaKeySystem Uuid.size is nullptr!"); + std::string mimeTypePtr = std::string(mimeType); + DRM_CHECK_AND_RETURN_RET_LOG(mimeTypePtr.size() != 0, false, "MediaKeySystem mimeTypePtr.size is nullptr!"); + + OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); + + OHOS::DrmStandard::ContentProtectionLevel securityLevel = + (OHOS::DrmStandard::ContentProtectionLevel)ContentProtectionLevel; + if ((securityLevel <= OHOS::DrmStandard::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN) || + (securityLevel >= OHOS::DrmStandard::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_MAX)) { + DRM_ERR_LOG("ContentProtectionLevel is invalid"); + return false; + } + isSupported = fatory->IsMediaKeySystemSupported(uuidPtr, mimeTypePtr, securityLevel); + return isSupported; +} + +Drm_ErrCode OH_MediaKeySystem_GetMediaKeySystems(DRM_MediaKeySystemDescription *description, uint32_t *count) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GetMediaKeySystems enter"); + DRM_CHECK_AND_RETURN_RET_LOG((description != nullptr), DRM_ERR_INVALID_VAL, "description is nullptr"); + DRM_CHECK_AND_RETURN_RET_LOG((count != nullptr), DRM_ERR_INVALID_VAL, "count is nullptr"); + std::map keySystemNames; + OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); + int32_t ret = fatory->GetMediaKeySystems(keySystemNames); + DRM_CHECK_AND_RETURN_RET_LOG((*count >= keySystemNames.size()), DRM_ERR_INVALID_VAL, + "GetMediaKeySystems failed because the count passed by is too small."); + int32_t times = 0; + DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_ERR_OK), DRM_ERR_UNKNOWN, + "GetMediaKeySystems call Failed!"); + for (auto it = keySystemNames.begin(); it != keySystemNames.end(); it++) { + if (!IsUuidValid(it->second)) { + continue; + } + if (it->first.size() != 0) { + ret = strcpy_s(description[times].name, sizeof(description[times].name) - 1, it->first.c_str()); + if (ret != 0) { + DRM_ERR_LOG("OH_MediaKeySystem_GetMediaKeySystems memcpy_s description faild!"); + return DRM_ERR_NO_MEMORY; + } + } + if (it->second.size() == (sizeof(description[times].uuid) * BASE_CONVERSION_OPERATOR)) { + for (size_t i = 0; i < sizeof(description[times].uuid) * BASE_CONVERSION_OPERATOR; + i += BASE_CONVERSION_OPERATOR) { + std::string byteStr = it->second.substr(i, BASE_CONVERSION_OPERATOR); + uint8_t byte = static_cast(std::stoi(byteStr, nullptr, HEXADECIMAL)); + description[times].uuid[i/BASE_CONVERSION_OPERATOR] = byte; + } + } + times++; + } + if (keySystemNames.size() == 0) { + DRM_ERR_LOG("plugin not exist."); + return DRM_ERR_UNKNOWN; + } + *count = keySystemNames.size(); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_Create(const char *name, MediaKeySystem **mediaKeySystem) +{ + DRM_INFO_LOG("OH_MediaKeySystem_Create enter."); + DrmTrace trace("OH_MediaKeySystem_Create"); + std::map errCodeMaps = { + {static_cast(DRM_INNER_ERR_INVALID_VAL), DRM_ERR_INVALID_VAL}, + {static_cast(DRM_INNER_ERR_SERVICE_FATAL_ERROR), DRM_ERR_SERVICE_DIED}, + {static_cast(DRM_INNER_ERR_MAX_SYSTEM_NUM_REACHED), DRM_ERR_MAX_SYSTEM_NUM_REACHED}, + {static_cast(DRM_INNER_ERR_UNKNOWN), DRM_ERR_UNKNOWN}, + {0, DRM_ERR_OK} + }; + DRM_CHECK_AND_RETURN_RET_LOG(((name != nullptr) && (mediaKeySystem != nullptr)), DRM_ERR_INVALID_VAL, + "parameter is error!"); + std::string nameStr = name; + DRM_CHECK_AND_RETURN_RET_LOG(nameStr.size() != 0, DRM_ERR_INVALID_VAL, "the size of nameStr is zero"); + + OHOS::sptr factory = MediaKeySystemFactoryImpl::GetInstance(); + DRM_CHECK_AND_RETURN_RET_LOG(factory != nullptr, DRM_ERR_UNKNOWN, "factory is nullptr!"); + OHOS::sptr system = nullptr; + int32_t result = factory->CreateMediaKeySystem(nameStr, &system); + Drm_ErrCode retCode = DRM_ERR_UNKNOWN; + if (errCodeMaps.find(result) != errCodeMaps.end()) { + retCode = errCodeMaps[result]; + } + DRM_CHECK_AND_RETURN_RET_LOG(system != nullptr, retCode, "system create by name failed!"); + + struct MediaKeySystemObject *object = new (std::nothrow) MediaKeySystemObject(system); + DRM_CHECK_AND_RETURN_RET_LOG(object != nullptr, DRM_ERR_UNKNOWN, "MediaKeySystemObject create failed!"); + + object->systemCallback_ = new (std::nothrow) MediaKeySystemCallbackCapi(); + if (object->systemCallback_ == nullptr) { + delete object; + DRM_ERR_LOG("MediaKeySystemObject create systemCallback failed!"); + return DRM_ERR_UNKNOWN; + } + int32_t ret = object->systemImpl_->SetCallback(object->systemCallback_); + if (ret != DRM_ERR_OK) { + delete object; + DRM_ERR_LOG("system set callback failed!"); + return DRM_ERR_UNKNOWN; + } + + *mediaKeySystem = object; + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_SetConfigurationString(MediaKeySystem *mediaKeySystem, const char *configName, + const char *value) +{ + DRM_INFO_LOG("OH_MediaKeySystem_SetConfigurationString enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_SetConfigurationString parameter is error!"); + + int32_t result = DRM_ERR_OK; + std::string name(configName); + DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetConfigurationString configName.size is not zero!"); + std::string valuePtr(value); + DRM_CHECK_AND_RETURN_RET_LOG(valuePtr.size() != 0, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetConfigurationString value.size is not zero!"); + + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetConfigurationString inner systemImpl is nullptr!"); + result = systemObject->systemImpl_->SetConfigurationString(name, valuePtr); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_SetConfigurationString mediaKeySystemImpl::SetConfigurationString faild!"); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_GetConfigurationString(MediaKeySystem *mediaKeySystem, const char *configName, + char *value, int32_t valueLen) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GetConfigurationString enter"); + DRM_CHECK_AND_RETURN_RET_LOG( + ((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen > 0)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetConfigurationString params is error!"); + + std::string valuePtr; + int32_t result = DRM_ERR_UNKNOWN; + std::string name = std::string(configName); + DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, + "configName.size is not zero!"); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_GetConfigurationString faild!"); + result = systemObject->systemImpl_->GetConfigurationString(name, valuePtr); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "mediaKeySystemImpl::GetConfigurationString faild!"); + DRM_CHECK_AND_RETURN_RET_LOG(valueLen >= (int32_t)valuePtr.size(), DRM_ERR_INVALID_VAL, + "The space for value is too small"); + memset_s(value, valueLen, 0, valueLen); + int32_t ret = memcpy_s(value, valuePtr.size(), valuePtr.c_str(), valuePtr.size()); + if (ret != 0) { + DRM_ERR_LOG("OH_MediaKeySystem_GetConfigurationString memcpy_s value failed!"); + return DRM_ERR_NO_MEMORY; + } + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_SetConfigurationByteArray(MediaKeySystem *mediaKeySystem, + const char *configName, uint8_t *value, int32_t valueLen) + +{ + DRM_INFO_LOG("OH_MediaKeySystem_SetConfigurationByteArray enter."); + DRM_CHECK_AND_RETURN_RET_LOG( + ((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen > 0)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_SetConfigurationByteArray params is error!"); + + int32_t result = DRM_ERR_OK; + std::string name(configName); + DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetConfigurationByteArray configName.size is not zero!"); + uint8_t *valueDataPtr = reinterpret_cast(value); + DRM_CHECK_AND_RETURN_RET_LOG(valueDataPtr != nullptr, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetConfigurationByteArray value is nullptr!"); + std::vector valueptr(valueDataPtr, valueDataPtr + valueLen); + DRM_CHECK_AND_RETURN_RET_LOG(valueptr.size() != 0, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetConfigurationByteArray value.size is not zero!"); + + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::SetConfigurationByteArray faild!"); + result = systemObject->systemImpl_->SetConfigurationByteArray(name, valueptr); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_SetConfigurationByteArray mediaKeySystemImpl::SetConfigurationByteArray faild!"); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_GetConfigurationByteArray(MediaKeySystem *mediaKeySystem, + const char *configName, uint8_t *value, int32_t *valueLen) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GetConfigurationByteArray enter"); + DRM_CHECK_AND_RETURN_RET_LOG( + ((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen != nullptr)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetConfigurationByteArray parameter is error!"); + + std::vector valuePtr; + int32_t result = DRM_ERR_OK; + std::string name = std::string(configName); + DRM_CHECK_AND_RETURN_RET_LOG(name.size() != 0, DRM_ERR_INVALID_VAL, + "configName.size is not zero!"); + + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_GetConfigurationByteArray faild!"); + result = systemObject->systemImpl_->GetConfigurationByteArray(name, valuePtr); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "mediaKeySystemImpl::GetConfigurationByteArray faild!"); + DRM_CHECK_AND_RETURN_RET_LOG(*valueLen >= (int32_t)valuePtr.size(), DRM_ERR_INVALID_VAL, + "The space for value is too small!"); + *valueLen = valuePtr.size(); + int32_t ret = memcpy_s(value, valuePtr.size(), valuePtr.data(), valuePtr.size()); + if (ret != 0) { + DRM_ERR_LOG("OH_MediaKeySystem_GetConfigurationByteArray memcpy_s value faild!"); + return DRM_ERR_NO_MEMORY; + } + return DRM_ERR_OK; +} + +static Drm_ErrCode vectorToClist(std::vector &metrics, + DRM_Statistics *statistics) +{ + DRM_INFO_LOG("vectorToCArray start."); + memset_s(statistics, sizeof(DRM_Statistics), 0, sizeof(DRM_Statistics)); + statistics->statisticsCount = metrics.size(); + DRM_CHECK_AND_RETURN_RET_LOG((statistics->statisticsCount <= MAX_STATISTICS_COUNT), DRM_ERR_NO_MEMORY, + "statisticsCount err!"); + for (size_t i = 0; i < metrics.size(); i++) { + if (metrics[i].name.size() == 0 || metrics[i].name.size() > sizeof(statistics->statisticsName[i])) { + continue; + } + int32_t ret = memcpy_s(statistics->statisticsName[i], + sizeof(statistics->statisticsName[i]), metrics[i].name.c_str(), metrics[i].name.size()); + if (ret != 0) { + DRM_ERR_LOG(" memcpy_s faild!"); + return DRM_ERR_NO_MEMORY; + } + if (metrics[i].value.size() != 0) { + ret = memcpy_s(statistics->statisticsDescription[i], + sizeof(statistics->statisticsDescription[i]), metrics[i].value.c_str(), metrics[i].value.size()); + if (ret != 0) { + DRM_ERR_LOG(" memcpy_s faild!"); + return DRM_ERR_NO_MEMORY; + } + } + } + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_GetStatistics(MediaKeySystem *mediaKeySystem, DRM_Statistics *statistics) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GetStatistics enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (statistics != nullptr)), DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_GetStatistics params is error!"); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + std::vector metrics; + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::GetStatistics inner systemImpl is nullptr!"); + int32_t result = systemObject->systemImpl_->GetStatistics(metrics); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_GetStatistics systemObject is nullptr!"); + Drm_ErrCode ret = vectorToClist(metrics, statistics); + DRM_CHECK_AND_RETURN_RET_LOG(statistics != nullptr, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_GetStatistics statistics obtained is nullptr!"); + return ret; +} + +Drm_ErrCode OH_MediaKeySystem_GetMaxContentProtectionLevel(MediaKeySystem *mediaKeySystem, + DRM_ContentProtectionLevel *contentProtectionLevel) +{ + DRM_INFO_LOG("GetMaxContentProtectionLevel enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (contentProtectionLevel != nullptr)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetMaxContentProtectionLevel parameter is error!"); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::GetMaxContentProtectionLevel faild!"); + int32_t result = DRM_ERR_OK; + ContentProtectionLevel level = + ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN; + result = systemObject->systemImpl_->GetMaxContentProtectionLevel(&level); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_GetMaxContentProtectionLevel fail!"); + if (level <= ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN || + level >= ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_MAX) { + DRM_ERR_LOG("the level obtained is beyond reasonable range!"); + return DRM_ERR_UNKNOWN; + } + *contentProtectionLevel = static_cast(level); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_GenerateKeySystemRequest(MediaKeySystem *mediaKeySystem, uint8_t *request, + int32_t *requestLen, char *defaultUrl, int32_t defaultUrlLen) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GenerateKeySystemRequest enter"); + DrmTrace trace("OH_MediaKeySystem_GenerateKeySystemRequest"); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (request != nullptr) && (requestLen != nullptr) && + (*requestLen > 0) && (defaultUrl != nullptr) && (defaultUrlLen > 0)), + DRM_ERR_INVALID_VAL, "Incorrect parameters of OH_MediaKeySystem_GenerateKeySystemRequest!"); + std::vector requestData; + std::string defaultUrlData; + + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::GenerateKeySystemRequest faild!"); + int32_t result = systemObject->systemImpl_->GenerateKeySystemRequest(requestData, defaultUrlData); + DRM_CHECK_AND_RETURN_RET_LOG(((result == DRM_ERR_OK) && (requestData.size() != 0)), DRM_ERR_UNKNOWN, + "MediaKeySystemImpl GenerateKeySystemRequest failed!"); + int32_t ret = memcpy_s(request, *requestLen, requestData.data(), requestData.size()); + *requestLen = requestData.size(); + DRM_CHECK_AND_RETURN_RET_LOG(ret == 0, DRM_ERR_NO_MEMORY, + "OH_MediaKeySystem_GenerateKeySystemRequest memcpy_s request failed!"); + ret = memset_s(defaultUrl, defaultUrlLen, 0, defaultUrlLen); + DRM_CHECK_AND_RETURN_RET_LOG(ret == 0, DRM_ERR_NO_MEMORY, + "OH_MediaKeySystem_GenerateKeySystemRequest memset_s defaultUrl failed!"); + if (defaultUrlData.size() != 0) { + ret = memcpy_s(defaultUrl, defaultUrlLen, defaultUrlData.data(), defaultUrlData.size()); + DRM_CHECK_AND_RETURN_RET_LOG(ret == 0, DRM_ERR_NO_MEMORY, + "OH_MediaKeySystem_GenerateKeySystemRequest memcpy_s defaultUrl failed!"); + } + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_ProcessKeySystemResponse(MediaKeySystem *mediaKeySystem, + uint8_t *response, int32_t responseLen) +{ + DRM_INFO_LOG("OH_MediaKeySystem_ProcessKeySystemResponse enter."); + int64_t beginTime = std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()).count(); + DrmTrace trace("OH_MediaKeySystem_ProcessKeySystemResponse"); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (response != nullptr) && (responseLen > 0)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_ProcessKeySystemResponse parameter is error!"); + int32_t result = DRM_ERR_OK; + std::vector keySystemResponse(response, response + responseLen); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::ProcessKeySystemResponse faild!"); + result = systemObject->systemImpl_->ProcessKeySystemResponse(keySystemResponse); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_ProcessKeySystemResponse systemObject is nullptr!"); + ConfigParser::WriteEndEvent(0, 0, std::string("OH_MediaKeySystem_ProcessKeySystemResponse"), beginTime); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_GetCertificateStatus(MediaKeySystem *mediaKeySystem, DRM_CertificateStatus *certStatus) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GetCertificateStatus enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (certStatus != nullptr)), DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_GetCertificateStatus parameter is error!"); + CertificateStatus CertStatus; + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::GetCertificateStatus faild!"); + int32_t result = systemObject->systemImpl_->GetCertificateStatus(&CertStatus); + if (result != DRM_ERR_OK) { + *certStatus = CERT_STATUS_UNAVAILABLE; + DRM_ERR_LOG("OH_MediaKeySystem_GetCertificateStatus faild!"); + return DRM_ERR_UNKNOWN; + } + *certStatus = (DRM_CertificateStatus)((int32_t)(CertStatus)); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_SetMediaKeySystemCallback(MediaKeySystem *mediaKeySystem, + MediaKeySystem_Callback callback) +{ + DRM_INFO_LOG("OH_MediaKeySystem_SetMediaKeySystemCallback enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (callback != nullptr)), DRM_ERR_INVALID_VAL, + "parameter is error!"); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetMediaKeySystemCallback faild!"); + systemObject->systemCallback_->SetCallbackReference(callback); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_SetCallback(MediaKeySystem *mediaKeySystem, OH_MediaKeySystem_Callback callback) +{ + DRM_INFO_LOG("OH_MediaKeySystem_SetCallback enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (callback != nullptr)), DRM_ERR_INVALID_VAL, + "parameter is error!"); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_SetCallback faild!"); + systemObject->systemCallback_->SetCallbackReference(mediaKeySystem, callback); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_CreateMediaKeySession(MediaKeySystem *mediaKeySystem, DRM_ContentProtectionLevel *level, + MediaKeySession **mediaKeySession) +{ + DRM_INFO_LOG("OH_MediaKeySystem_CreateMediaKeySession enter."); + DrmTrace trace("OH_MediaKeySystem_CreateMediaKeySession"); + std::map errCodeMaps = { + {static_cast(DRM_INNER_ERR_SERVICE_FATAL_ERROR), DRM_ERR_SERVICE_DIED}, + {static_cast(DRM_INNER_ERR_MAX_SESSION_NUM_REACHED), DRM_ERR_MAX_SESSION_NUM_REACHED}, + {static_cast(DRM_INNER_ERR_UNKNOWN), DRM_ERR_UNKNOWN}, + {0, DRM_ERR_OK} + }; + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (level != nullptr) && (mediaKeySession != nullptr) && + (*level > CONTENT_PROTECTION_LEVEL_UNKNOWN) && (*level < CONTENT_PROTECTION_LEVEL_MAX)), + DRM_ERR_INVALID_VAL, "mediaKeySystem is nullptr!"); + struct MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::CreateMediaKeySession faild!"); + int32_t secure = static_cast(*level); + ContentProtectionLevel secureLevel = + static_cast(secure); + OHOS::sptr keySessionImpl = nullptr; + int32_t ret = systemObject->systemImpl_->CreateMediaKeySession(secureLevel, &keySessionImpl); + Drm_ErrCode retCode = DRM_ERR_UNKNOWN; + if (errCodeMaps.find(ret) != errCodeMaps.end()) { + retCode = errCodeMaps[ret]; + } + DRM_CHECK_AND_RETURN_RET_LOG(ret == DRM_ERR_OK, retCode, "session create return failed!"); + DRM_CHECK_AND_RETURN_RET_LOG(keySessionImpl != nullptr, DRM_ERR_INVALID_VAL, "session create failed!"); + + struct MediaKeySessionObject *sessionObject = new (std::nothrow) MediaKeySessionObject(keySessionImpl); + DRM_CHECK_AND_RETURN_RET_LOG(sessionObject != nullptr, DRM_ERR_NO_MEMORY, "MediaKeySessionObject create failed!"); + + sessionObject->sessionCallback_ = new (std::nothrow) MediaKeySessionCallbackCapi(); + if (sessionObject->sessionCallback_ == nullptr) { + delete sessionObject; + DRM_ERR_LOG("MediaKeySessionObject create sessionCallback failed!"); + return DRM_ERR_NO_MEMORY; + } + ret = sessionObject->sessionImpl_->SetCallback(sessionObject->sessionCallback_); + if (ret != DRM_ERR_OK) { + delete sessionObject; + DRM_ERR_LOG("session set callback failed!"); + return DRM_ERR_UNKNOWN; + } + + *mediaKeySession = static_cast(sessionObject); + return DRM_ERR_OK; +} + +static Drm_ErrCode vectorToC2DArray(std::vector> licenseIds, + DRM_OfflineMediakeyIdArray *offlineMediaKeyIds) +{ + DRM_INFO_LOG("vectorToC2DArray enter."); + if (licenseIds.size() >= MAX_OFFLINE_MEDIA_KEY_ID_COUNT) { + DRM_ERR_LOG("licenseIds size too large!"); + return DRM_ERR_NO_MEMORY; + } + + offlineMediaKeyIds->idsCount = (uint32_t)(licenseIds.size()); + for (size_t i = 0; i < licenseIds.size(); i++) { + if (licenseIds[i].size() != 0) { + offlineMediaKeyIds->idsLen[i] = (int32_t)(licenseIds[i].size()); + int32_t ret = memcpy_s(offlineMediaKeyIds->ids[i], MAX_OFFLINE_MEDIA_KEY_ID_LEN, licenseIds[i].data(), + licenseIds[i].size()); + if (ret != 0) { + DRM_ERR_LOG("memcpy_s faild!"); + return DRM_ERR_NO_MEMORY; + } + } + } + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_GetOfflineMediaKeyIds(MediaKeySystem *mediaKeySystem, + DRM_OfflineMediakeyIdArray *offlineMediaKeyIds) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GetOfflineMediaKeyIds enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyIds != nullptr)), DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_GetOfflineMediaKeyIds parameter is error!"); + std::vector> licenseIds; + + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::GetOfflineMediaKeyIds faild!"); + int32_t result = systemObject->systemImpl_->GetOfflineMediaKeyIds(licenseIds); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_GetOfflineMediaKeyIds faild!"); + if (licenseIds.size() == 0) { + DRM_DEBUG_LOG("licenseIds.data() is nullptr!"); + return DRM_ERR_OK; + } + result = vectorToC2DArray(licenseIds, offlineMediaKeyIds); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_NO_MEMORY, + "vectorToC2DArray faild!"); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_GetOfflineMediaKeyStatus(MediaKeySystem *mediaKeySystem, + uint8_t *offlineMediaKeyId, int32_t offlineMediaKeyIdLen, DRM_OfflineMediaKeyStatus *status) +{ + DRM_INFO_LOG("OH_MediaKeySystem_GetOfflineMediaKeyStatus enter"); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyId != nullptr) && + (offlineMediaKeyIdLen > 0) && (offlineMediaKeyIdLen <= MAX_OFFLINE_MEDIA_KEY_ID_LEN) && (status != nullptr)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetOfflineMediaKeyStatus parameter is error!"); + int32_t result = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + + std::vector licenseIdVec(offlineMediaKeyId, offlineMediaKeyId + offlineMediaKeyIdLen); + OfflineMediaKeyStatus offlineMediaKeyStatus = + OfflineMediaKeyStatus::OFFLINELICENSESTATUS_UNKNOWN; + + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::GetOfflineMediaKeyStatus faild!"); + result = systemObject->systemImpl_->GetOfflineMediaKeyStatus(licenseIdVec, offlineMediaKeyStatus); + if (result != DRM_ERR_OK) { + DRM_ERR_LOG("OH_MediaKeySystem_GetOfflineMediaKeyStatus faild!"); + return DRM_ERR_UNKNOWN; + } + DRM_OfflineMediaKeyStatus CofflineMediaKeyStatus = (DRM_OfflineMediaKeyStatus)((int32_t)(offlineMediaKeyStatus)); + if (CofflineMediaKeyStatus < OFFLINE_MEDIA_KEY_STATUS_UNKNOWN || + CofflineMediaKeyStatus > OFFLINE_MEDIA_KEY_STATUS_INACTIVE) { + DRM_ERR_LOG("OH_MediaKeySystem_GetOfflineMediaKeyStatus faild!"); + return DRM_ERR_UNKNOWN; + } + *status = CofflineMediaKeyStatus; + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_ClearOfflineMediaKeys(MediaKeySystem *mediaKeySystem, + uint8_t *offlineMediaKeyId, int32_t offlineMediaKeyIdLen) +{ + DRM_INFO_LOG("OH_MediaKeySystem_ClearOfflineMediaKeys enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyId != nullptr) && + (offlineMediaKeyIdLen > 0) && (offlineMediaKeyIdLen <= MAX_OFFLINE_MEDIA_KEY_ID_LEN)), + DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_ClearOfflineMediaKeys parameter is error!"); + int32_t result = DRM_ERR_OK; + std::vector licenseIdVec(offlineMediaKeyId, offlineMediaKeyId + offlineMediaKeyIdLen); + DRM_CHECK_AND_RETURN_RET_LOG(licenseIdVec.size() != 0, DRM_ERR_INVALID_VAL, + "OH_MediaKeySystem_ClearOfflineMediaKeys configName.size is not zero!"); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::OH_MediaKeySystem_ClearOfflineMediaKeys inner systemImpl is nullptr!"); + result = systemObject->systemImpl_->ClearOfflineMediaKeys(licenseIdVec); + DRM_CHECK_AND_RETURN_RET_LOG(result == DRM_ERR_OK, DRM_ERR_UNKNOWN, + "OH_MediaKeySystem_ClearOfflineMediaKeys mediaKeySystemImpl::ClearOfflineMediaKeys faild!"); + return DRM_ERR_OK; +} + +Drm_ErrCode OH_MediaKeySystem_Destroy(MediaKeySystem *mediaKeySystem) +{ + DRM_INFO_LOG("OH_MediaKeySystem_Destroy enter."); + DRM_CHECK_AND_RETURN_RET_LOG(mediaKeySystem != nullptr, DRM_ERR_INVALID_VAL, "mediaKeySystem is nullptr!"); + + struct MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "mediaKeySystemImpl::OH_MediaKeySystem_Destroy faild!"); + int32_t ret = systemObject->systemImpl_->Release(); + DRM_CHECK_AND_RETURN_RET_LOG(ret == DRM_ERR_OK, DRM_ERR_UNKNOWN, "call media key system release failed!"); + delete mediaKeySystem; + mediaKeySystem = nullptr; + return DRM_ERR_OK; +} diff --git a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp index cf02385..03e0464 100644 --- a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp +++ b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp @@ -1,3950 +1,3979 @@ -/* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. - * 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 -#include -#include -#include -#include "cstdio" -#include "cstdlib" -#include -#include "native_drm_common.h" -#include "native_drm_err.h" -#include "gmock/gmock.h" -#include "native_drm_base.h" -#include "native_drm_object.h" -#include "imedia_decrypt_module_service.h" -#include "native_mediakeysession.h" -#include "native_mediakeysystem.h" -#include "cstdbool" -#include "drm_types.h" -#include "drm_framework_unittest.h" -#include "drm_log.h" -#include "drm_death_recipient.h" -#include "key_session_impl.h" -#include "imedia_key_system_service.h" -#include "media_key_system_factory_impl.h" -#include "media_key_system_service_callback_stub.h" -#include "http.h" -#include "ashmem.h" -#include "media_decrypt_module_service_proxy.h" -#include -#include -#include -#include "nocopyable.h" -#include "ipc_skeleton.h" -#include "imedia_key_session_service.h" -#include "imedia_key_session_service_callback.h" -#include "media_key_session_service_callback_stub.h" - -#define DRM_SAMPLE_CHECK_AND_RETURN_RET_LOG(cond, ret, fmt, ...) \ - do { \ - if ((cond)) { \ - printf(fmt, ##__VA_ARGS__); \ - return ret; \ - } \ - } while (0) -#define DRM_SAMPLE_INFO_LOG(fmt, ...) fprintf(stdout, "[INFO] " fmt "\n", ##__VA_ARGS__) -#define DRM_SAMPLE_ERROR_LOG(fmt, ...) fprintf(stdout, "[ERROR] " fmt "\n", ##__VA_ARGS__) -#define OFFRESPONSE \ - { \ - 0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, \ - 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, \ - 0x4E, 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, \ - 0x48, 0x64, 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, \ - 0x34, 0x5A, 0x48, 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D \ - } -#define REQUESTINFODATA \ - { \ - 0x00, 0x00, 0x00, 0x8B, 0x70, 0x73, 0x73, 0x68, 0x00, 0x00, 0x00, \ - 0x00, 0x3D, 0x5E, 0x6D, 0x35, 0x9B, 0x9A, 0x41, 0xE8, 0xB8, \ - 0x43, 0xDD, 0x3C, 0x6E, 0x72, 0xC4, 0x2C, 0x00, 0x00, 0x00, \ - 0x6B, 0x7B, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, \ - 0x22, 0x3A, 0x22, 0x56, 0x31, 0x2E, 0x30, 0x22, 0x2C, 0x22, \ - 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x22, \ - 0x3A, 0x22, 0x64, 0x48, 0x4D, 0x74, 0x4D, 0x6A, 0x59, 0x30, \ - 0x4C, 0x54, 0x45, 0x77, 0x4F, 0x44, 0x41, 0x74, 0x59, 0x57, \ - 0x56, 0x7A, 0x22, 0x2C, 0x22, 0x6B, 0x69, 0x64, 0x73, 0x22, \ - 0x3A, 0x5B, 0x22, 0x47, 0x2B, 0x45, 0x6B, 0x2F, 0x2B, 0x58, \ - 0x6D, 0x55, 0x6B, 0x70, 0x42, 0x48, 0x51, 0x67, 0x58, 0x59, \ - 0x57, 0x51, 0x51, 0x49, 0x67, 0x3D, 0x3D, 0x22, 0x5D, 0x2C, \ - 0x22, 0x65, 0x6E, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x22, \ - 0x3A, 0x22, 0x63, 0x62, 0x63, 0x31, 0x22, 0x7D \ - } -#define OFFREQUESTINFODATA \ - { \ - 0x00, 0x00, 0x00, 0x8b, 0x70, 0x73, 0x73, 0x68, 0x00, 0x00, 0x00, \ - 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, \ - 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x00, \ - 0x6b, 0x7b, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, \ - 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, \ - 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, \ - 0x3a, 0x22, 0x64, 0x48, 0x4d, 0x74, 0x4d, 0x6a, 0x59, 0x30, \ - 0x4c, 0x54, 0x45, 0x77, 0x4f, 0x44, 0x41, 0x74, 0x59, 0x57, \ - 0x56, 0x7a, 0x22, 0x2c, 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, \ - 0x3a, 0x5b, 0x22, 0x47, 0x2b, 0x45, 0x6b, 0x2f, 0x2b, 0x58, \ - 0x6d, 0x55, 0x6b, 0x70, 0x42, 0x48, 0x51, 0x67, 0x58, 0x59, \ - 0x57, 0x51, 0x51, 0x49, 0x67, 0x3d, 0x3d, 0x22, 0x5d, 0x2c, \ - 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, \ - 0x3a, 0x22, 0x63, 0x62, 0x63, 0x31, 0x22, 0x7d \ - } -#define ONRESPONSE \ - { \ - 0x30, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, \ - 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, \ - 0x4E, 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, \ - 0x48, 0x64, 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, \ - 0x34, 0x5A, 0x48, 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D \ - } - - -#define LICENSE_URL "http://license.dev.trustdta.com:8080/drmproxy/v3/getLicense" -#define PROVISION_URL "https://wiseplay-prv.cloud.huawei.com/provision/v1/wiseplay" -using namespace testing::ext; -using namespace std; - -namespace { -const int32_t STEP_ONE = 1; -const int32_t STEP_TWO = 2; -const int32_t STEP_THREE = 3; -const int32_t STEP_FOUR = 4; -} - -namespace OHOS { -namespace DrmStandard { - -bool g_isWisePlay = false; -void DrmFrameworkUnitTest::SetUpTestCase(void) {} - -void DrmFrameworkUnitTest::TearDownTestCase(void) {} - -static const char *GetUuid() -{ - if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) { - return "com.clearplay.drm"; - } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) { - return "com.wiseplay.drm"; - } else { - return "ERROR"; - } -} - -void DrmFrameworkUnitTest::SetUp() -{ - if (strcmp(GetUuid(), "com.wiseplay.drm") == 0) { - g_isWisePlay = true; - } - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char request[12288] = { 0 }; // 12288:request len - int32_t requestLen = 12288; // 12288:request len - char defaultUrl[2048] = { 0 }; // 2048:url len - int32_t defaultUrlLen = 2048; // 2048:url len - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (certStatus == CERT_STATUS_NOT_PROVISIONED) { - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, - defaultUrlLen); - unsigned char KeySystemResponse[12288] = OFFRESPONSE; - int32_t KeySystemResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(PROVISION_URL, request, requestLen, KeySystemResponse, &KeySystemResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - KeySystemResponseLen = 50; // 50 is the length of system response - } - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; -} - -void DrmFrameworkUnitTest::TearDown() {} - -static const char *GetDrmPlugin() -{ - if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) { - return "killall -9 clearplay_host"; - } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) { - return "killall -9 wiseplay_host"; - } else { - return "ERROR"; - } -} - -Drm_ErrCode TestSystemEventCallBack(DRM_EventType eventType, unsigned char *info, - int32_t infoLen, char *extra) -{ - DRM_SAMPLE_INFO_LOG("TestSystemEventCallBack ok"); - return DRM_ERR_OK; -} - -Drm_ErrCode TestSessoinEventCallBack(DRM_EventType eventType, unsigned char *info, - int32_t infoLen, char *extra) -{ - DRM_SAMPLE_INFO_LOG("TestSessoinEventCallBack ok"); - return DRM_ERR_OK; -} - -Drm_ErrCode TestSessoinKeyChangeCallBack(DRM_KeysInfo *keysInfo, bool hasNewGoodKeys) -{ - DRM_SAMPLE_INFO_LOG("TestSessoinKeyChangeCallBack ok"); - return DRM_ERR_OK; -} - -Drm_ErrCode TestSystemEventCallBackWithObj(MediaKeySystem *mediaKeySystem, DRM_EventType eventType, - uint8_t *info, int32_t infoLen, char *extra) -{ - DRM_SAMPLE_INFO_LOG("TestSystemEventCallBackWithObj ok"); - if (mediaKeySystem == nullptr) { - return DRM_ERR_UNKNOWN; - } - DRM_SAMPLE_INFO_LOG("Event: event type: %d", eventType); - DRM_SAMPLE_INFO_LOG("Event: the info body is: "); - if (info != nullptr) { - for (int32_t i = 0; i < infoLen; i++) { - DRM_SAMPLE_INFO_LOG("%x", info[i]); - } - } - if (extra != nullptr) { - DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra); - } - return DRM_ERR_OK; -} - -Drm_ErrCode TestSessoinEventCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_EventType eventType, - uint8_t *info, int32_t infoLen, char *extra) -{ - DRM_SAMPLE_INFO_LOG("TestSessoinEventCallBackWithObj ok"); - if (mediaKeySessoin == nullptr) { - return DRM_ERR_UNKNOWN; - } - DRM_SAMPLE_INFO_LOG("Event: the event type: %d", eventType); - DRM_SAMPLE_INFO_LOG("Event: the info body is: "); - if (info != nullptr) { - for (int32_t i = 0; i < infoLen; i++) { - DRM_SAMPLE_INFO_LOG("%x", info[i]); - } - } - if (extra != nullptr) { - DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra); - } - return DRM_ERR_OK; -} - -Drm_ErrCode TestSessoinKeyChangeCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_KeysInfo *keysInfo, - bool hasNewGoodKeys) -{ - DRM_SAMPLE_INFO_LOG("TestSessoinKeyChangeCallBackWithObj ok"); - if (mediaKeySessoin == nullptr) { - return DRM_ERR_UNKNOWN; - } - for (uint32_t i = 0; i < keysInfo->keysInfoCount; i++) { - for (uint32_t j = 0; j < MAX_KEY_ID_LEN; j += STEP_FOUR) { - DRM_SAMPLE_INFO_LOG("KeyChangedEvent: keyid is: "); - DRM_SAMPLE_INFO_LOG("%x %x %x %x", - keysInfo->keyId[i][j], keysInfo->keyId[i][j + STEP_ONE], - keysInfo->keyId[i][j + STEP_TWO], keysInfo->keyId[i][j + STEP_THREE]); - } - DRM_SAMPLE_INFO_LOG("KeyChangedEvent: statusValue %s", keysInfo->statusValue[i]); - } - return DRM_ERR_OK; -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedNormal_001, TestSize.Level0) -{ - bool supported; - supported = OH_MediaKeySystem_IsSupported(GetUuid()); - EXPECT_EQ(supported, true); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2Normal_002, TestSize.Level0) -{ - bool supported; - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "video/mp4"); - EXPECT_EQ(supported, true); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3Normal_003, TestSize.Level0) -{ - bool supported; - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, true); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedAbNormal_004, TestSize.Level0) -{ - bool supported = true; - supported = OH_MediaKeySystem_IsSupported("com.drm.clearpla"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported(""); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported(nullptr); - EXPECT_EQ(supported, false); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2AbNormal_005, TestSize.Level0) -{ - bool supported = true; - supported = OH_MediaKeySystem_IsSupported2("com.drm.clearpla", "video/mp4"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2("", "video/mp4"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2(nullptr, "video/mp4"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "ideo/mp4"); - if (g_isWisePlay) { - EXPECT_EQ(supported, true); - } else { - EXPECT_EQ(supported, false); - } - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), ""); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), nullptr); - EXPECT_EQ(supported, false); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3AbNormal_006, TestSize.Level0) -{ - bool supported = true; - supported = OH_MediaKeySystem_IsSupported3("com.drm.clearpla", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3("", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(nullptr, "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "ideo/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - if (g_isWisePlay) { - EXPECT_EQ(supported, true); - } else { - EXPECT_EQ(supported, false); - } - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), nullptr, CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", - (DRM_ContentProtectionLevel)(CONTENT_PROTECTION_LEVEL_UNKNOWN - 1)); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", - (DRM_ContentProtectionLevel)CONTENT_PROTECTION_LEVEL_MAX); - EXPECT_EQ(supported, false); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Test Creating DRM Instance - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_007, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_GT(contentProtectionLevel, 0); - if (mediaKeySystem != nullptr) { - OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - } -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Testing for an incorrect uuid and unsuccessful creation of DRM instance. - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_008, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create("com.drm.clerpay", &mediaKeySystem); - EXPECT_EQ(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Test passed in an empty uuid and failed to create a DRM instance. - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_009, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create("", &mediaKeySystem); - EXPECT_EQ(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: After the DRM instance is created, it is destroyed, and then the subsequent interface is called. - * The interface returns unsuccessful. - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_010, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); - mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test and create sessions - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Test Creating Sessions - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionNormal_011, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test that the RequireSecureDecoderModule interface is functioning properly - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Testing that the RequireSecureDecoderModule interface is functioning properly - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleNormal_012, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_013, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "asdssadadsa", &requireSecureDecoder); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_014, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "", &requireSecureDecoder); - EXPECT_NE(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_015, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, nullptr, &requireSecureDecoder); - EXPECT_NE(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_016, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_017, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(nullptr, "video/mp4", &requireSecureDecoder); - EXPECT_NE(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: GenerateKeySystemRequest normal testing to obtain normal requests - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: GenerateKeySystemRequest obtained a normal request through normal testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestNormal_018, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: GenerateKeySystemRequest parameter exception testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: GenerateKeySystemRequest Parameter Exception Test - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestAbNormal_019, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char request[12288] = { 0 }; // 12288:request len - int32_t requestLen = 12288; // 12288:request len - char defaultUrl[2048] = { 0 }; // 2048:url len - int32_t defaultUrlLen = 2048; // 2048:url len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(nullptr, request, &requestLen, defaultUrl, defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - requestLen = 12288; // 12288:request len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, nullptr, &requestLen, defaultUrl, - defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, nullptr, defaultUrl, defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - requestLen = 12288; // 12288:request len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, nullptr, defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - requestLen = 12288; // 12288:request len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_020, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_021, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char KeySystemResponse[12288] = OFFRESPONSE; - int32_t KeySystemResponseLen = 12288; - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(nullptr, KeySystemResponse, KeySystemResponseLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_022, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - int32_t KeySystemResponseLen = 12288; - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, nullptr, KeySystemResponseLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_023, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestNormal_024, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_025, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(nullptr, &info, &mediaKeyRequest); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_026, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, nullptr, &mediaKeyRequest); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_027, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_029, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[1] = { 0 }; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(nullptr, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_030, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[1] = { 0 }; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, nullptr, 0, - onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_031, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeySessionResponse[50] = OFFRESPONSE; - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), nullptr, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_032, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusNormal_033, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - unsigned char testData[139] = REQUESTINFODATA; - info.type = MEDIA_KEY_TYPE_ONLINE; - info.initDataLen = sizeof(testData); - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(nullptr, &mediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - - errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - if (g_isWisePlay) { - EXPECT_EQ(errNo, DRM_ERR_OK); - } else { - EXPECT_NE(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_037, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - errNo = OH_MediaKeySession_ClearMediaKeys(nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusNormal_038, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, info.initDataLen); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_039, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_040, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, nullptr, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_041, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsNormal_042, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediakeyIdArray offlineMediaKeyIds; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_043, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediakeyIdArray offlineMediaKeyIds; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(nullptr, &offlineMediaKeyIds); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_044, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestNormal_045, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestAbNormal_046, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - nullptr, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseNormal_047, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - if (!g_isWisePlay) { - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_048, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusNormal_049, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); - EXPECT_EQ(certStatus, 0); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusAbNormal_050, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(nullptr, &certStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringNormal_051, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = - OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); - if (g_isWisePlay) { - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_EQ(errNo, DRM_ERR_OK); - } - char value[32]; - int32_t valueLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "version", value, valueLen); - if (g_isWisePlay) { - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "version", value, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_NE(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 10); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringAbNormal_052, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(nullptr, "testConfigurationString", "gezhegezhegezhe"); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "", "gezhegezhegezhe"); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, nullptr, "gezhegezhegezhe"); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", ""); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationStringAbNormal_053, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "gezhegezhegezhe"); - if (g_isWisePlay) { - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_EQ(errNo, DRM_ERR_OK); - } - char value[32]; - int32_t valueLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationString(nullptr, "testConfigurationString", value, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "", value, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, nullptr, value, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayNormal_054, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, - sizeof(testArray)); - if (g_isWisePlay) { - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_EQ(errNo, DRM_ERR_OK); - } - unsigned char configByteArray[128]; - int32_t byteArrayLen = 128; - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "deviceUniqueId", configByteArray, - &byteArrayLen); - if (g_isWisePlay) { - EXPECT_EQ(errNo, DRM_ERR_OK); - } else { - EXPECT_NE(errNo, DRM_ERR_OK); - } - - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationByteArrayAbNormal_055, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(nullptr, "testConfigurationByteArray", testArray, - sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "", testArray, sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, nullptr, testArray, sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr, - sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayAbNormal_056, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, - sizeof(testArray)); - unsigned char configByteArray[32]; - int32_t byteArrayLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationByteArray(nullptr, "testConfigurationByteArray", configByteArray, - &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "", configByteArray, &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, nullptr, configByteArray, &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr, - &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, - nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsNormal_057, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_Statistics statistics; - errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsAbNormal_058, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_Statistics statistics; - errNo = OH_MediaKeySystem_GetStatistics(nullptr, &statistics); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Test Creating DRM Instance - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetMaxContentProtectionLevelAbNormal_059, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(nullptr, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - if (mediaKeySystem != nullptr) { - OH_MediaKeySystem_Destroy(mediaKeySystem); - } -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysNormal_060, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysAbNormal_061, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (!g_isWisePlay) { - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysNormal_062, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (!g_isWisePlay) { - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_063, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = 139; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, 139, testData, 139); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (!g_isWisePlay) { - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -#define MAX_BUFF 139 -static void filldata(DRM_MediaKeyRequestInfo *info) -{ - unsigned char testData[139] = REQUESTINFODATA; - memset_s(info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info->initDataLen = sizeof(testData); - info->type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info->mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info->initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info->optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info->optionData[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - info->optionsCount = 1; -} - -const unsigned char TESTKEYRELEASERESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, - 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, - 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, - 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, - 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; -const unsigned char TESTKEYSESSIONRESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, - 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, - 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, - 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, - 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; - -static void filltest3(MediaKeySystem *mediaKeySystem, - MediaKeySession *mediaKeySession, unsigned char *keySystemResponse, int32_t KeySystemResponseLen) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, keySystemResponse, - KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - if (!g_isWisePlay) { - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - (uint8_t *)(TESTKEYRELEASERESPONSE), (int32_t)(sizeof(TESTKEYRELEASERESPONSE))); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GetContentProtectionLevel(nullptr, &sessionContentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_064, TestSize.Level0) -{ - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - int32_t KeySystemResponseLen = 12288; - unsigned char KeySystemResponse[12288] = OFFRESPONSE; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - KeySystemResponseLen = 50; - } - EXPECT_EQ(errNo, DRM_ERR_OK); - filltest3(mediaKeySystem, mediaKeySession, KeySystemResponse, KeySystemResponseLen); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - mediaKeySession = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - mediaKeySession = nullptr; - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_065, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_066, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sptr SessionServiceProxy = - sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy(); - sptr decryptModule; - SessionServiceProxy->GetMediaDecryptModule(decryptModule); - MessageParcel data; - DrmBuffer srcBuffer; - DrmBuffer dstBuffer; - bool secureDecodrtState = false; - CryptInfo cryptInfo; - decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); - decryptModule->Release(); - sptr callback = sessionObject->sessionImpl_->GetApplicationCallback(); - callback->~MediaKeySessionImplCallback(); - } - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - sptr serviceCallback = - new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_); - sptr Callback = new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_); - const std::vector data = { 0x01 }; - MessageParcel data1; - MessageParcel reply; - MessageOption option; - data1.WriteInt32(static_cast(OHOS::DrmStandard::DrmEventType::DRM_EVENT_PROVISION_REQUIRED)); - data1.WriteInt32(1); - data1.WriteInt32(data.size()); - for (auto it = data.begin(); it != data.end(); ++it) { - int32_t ret = data1.WriteUint8((*it)); - EXPECT_NE(ret, 0); - } - Callback->OnRemoteRequest(static_cast(IMediaKeySystemServiceCallbackIpcCode::COMMAND_SEND_EVENT), - data1, reply, option); - serviceCallback->SendEvent(OHOS::DrmStandard::DrmEventType::DRM_EVENT_PROVISION_REQUIRED, 1, data); - OHOS::sptr SystemCallbackCapi = - new (std::nothrow) MediaKeySystemCallbackCapi(); - SystemCallbackCapi->SetCallbackReference(&TestSystemEventCallBack); - SystemCallbackCapi->SendEvent("1", 1, data); - sptr SystemImplCallba = systemObject->systemImpl_->GetApplicationCallback(); - SystemImplCallba->~MediaKeySystemImplCallback(); - } - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_067, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - int32_t releaseRequestLen = 12288; // 12288:request len - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - uint8_t mediaKeyIdToRelease; - MediaKeySession *mediaKeySession = (MediaKeySession *)&mediaKeyIdToRelease; - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, 11, releaseRequest, // 11:len - &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)&releaseRequestLen, 0, - releaseRequest, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, 0, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, 11, // 11:len - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, - 11, nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, - 11, testKeyReleaseResponse, 0); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_068, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - unsigned char onlineMediaKeyId[88]; // 88:keyId len - uint32_t onlineMediaKeyIdLen = 88; // 88:keyId len - MediaKeySession *mediaKeySession = (MediaKeySession *)&onlineMediaKeyId; - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetMediaKeySessionCallbackNormal_069, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // test 3: system callback - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(nullptr, &TestSystemEventCallBack); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(nullptr, &sessionCallback); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_070, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(nullptr, &mediaKeySystem); - EXPECT_EQ(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_Create(GetUuid(), nullptr); - EXPECT_EQ(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_CreateMediaKeySession(nullptr, &contentProtectionLevel, &mediaKeySession); - EXPECT_EQ(mediaKeySession, nullptr); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, nullptr, &mediaKeySession); - EXPECT_EQ(mediaKeySession, nullptr); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, nullptr); - EXPECT_EQ(mediaKeySession, nullptr); - uint8_t mediaKeyIdToClear; - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&mediaKeyIdToClear, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, 11); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemDestroyAbNormal_071, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - systemObject->systemImpl_->~MediaKeySystemImpl(); - } - errNo = - OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); - EXPECT_NE(errNo, DRM_ERR_OK); - char value[32]; - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 32); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, - sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char configByteArray[32]; - int32_t byteArrayLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, - &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_Statistics statistics; - errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); - EXPECT_NE(errNo, DRM_ERR_OK); - contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_OH_MediaKeySystemDestroyAbNormal2_072, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - systemObject->systemImpl_->~MediaKeySystemImpl(); - } - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - MediaKeySession *OH_MediaKeySession2 = nullptr; - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &OH_MediaKeySession2); - EXPECT_EQ(OH_MediaKeySession2, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_OfflineMediakeyIdArray offlineMediaKeyIds; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1, - &OfflineMediaKeyStatus); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal_073, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); - } - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal2_074, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); - } - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = { 0 }; - int32_t testKeySessionResponseLen = 12288; - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySession_DestroyAbNormal3_075, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); - } - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)GetUuid(), - 11, releaseRequest, &releaseRequestLen); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal4_076, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); - } - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)GetUuid(), - 11, testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, (unsigned char *)GetUuid(), 1); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); - bool requireSecureDecoder; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal_077, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen, - testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0);} else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal2_078, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[2] = {0x07, 0x22}; - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_079, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen, - testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)("onlineMediaKeyId"), - 2, releaseRequest, &releaseRequestLen); // 2:len - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_080, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t KeySystemResponseLen = 12288; - unsigned char KeySystemResponse[12288] = OFFRESPONSE; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - KeySystemResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, KeySystemResponse, - KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[2] = {0x33, 0x22}; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); -} - -static void filltest(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, (uint8_t *)TESTKEYSESSIONRESPONSE, - (int32_t)(sizeof(TESTKEYSESSIONRESPONSE)), onlineMediaKeyId, &onlineMediaKeyIdLen); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - (uint8_t *)TESTKEYRELEASERESPONSE, (int32_t)(sizeof(TESTKEYRELEASERESPONSE))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, (unsigned char *)"onlineMediaKeyId", 1); - EXPECT_NE(errNo, DRM_ERR_OK); -} -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_081, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - filltest(mediaKeySystem, mediaKeySession); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); - sleep(1); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_082, TestSize.Level0) -{ - MediaKeySystem *mediaKeySystem = nullptr; - string name; - string uuid; - Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - ContentProtectionLevel securityLevel = - ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - OHOS::sptr keySessionImpl = nullptr; - systemObject->systemImpl_->~MediaKeySystemImpl(); - systemObject->systemImpl_->CreateMediaKeySession(securityLevel, &keySessionImpl); - keySessionImpl = nullptr; - MediaKeySystemCallback *allback = new MediaKeySystemCallback(); - allback->~MediaKeySystemCallback(); - OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); - fatory->Init(); - if (g_isWisePlay) { - name = "com.wiseplay.drm"; - } else { - name = "com.wiseplay.drm"; - } - fatory->GetMediaKeySystemUuid(name, uuid); - name = "com.test"; - fatory->GetMediaKeySystemUuid(name, uuid); - } - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_NE(errNo, DRM_ERR_OK); - MediaKeySystem *mediaKeySystem2 = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem2); - EXPECT_NE(mediaKeySystem2, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem2); - mediaKeySystem2 = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SessionImplAbNormal_083, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 50; - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - MediaKeySessionServiceCallback *Object = new MediaKeySessionServiceCallback(sessionObject->sessionImpl_); - std::map, MediaKeySessionKeyStatus> statusTable = { { { 0x01 }, - MediaKeySessionKeyStatus::MEDIA_KEY_SESSION_KEY_STATUS_USABLE } }; - bool hasNewGoodLicense = false; - Object->SendEventKeyChanged(statusTable, hasNewGoodLicense); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -static void killclearplay(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - std::vector licenseIdVec = { 0x01 }; - std::vector ReleaseRequest = { 0x01 }; - ContentProtectionLevel securityLevel; - system(GetDrmPlugin()); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - uint32_t result = sessionObject->sessionImpl_->GenerateOfflineReleaseRequest(licenseIdVec, ReleaseRequest); - EXPECT_NE(result, DRM_ERR_OK); - result = sessionObject->sessionImpl_->ProcessOfflineReleaseResponse(licenseIdVec, ReleaseRequest); - EXPECT_NE(result, DRM_ERR_OK); - result = sessionObject->sessionImpl_->GetContentProtectionLevel(&securityLevel); - EXPECT_NE(result, DRM_ERR_OK); - std::map licenseStatus2; - result = sessionObject->sessionImpl_->CheckMediaKeyStatus(licenseStatus2); - EXPECT_NE(result, DRM_ERR_OK); - result = sessionObject->sessionImpl_->RestoreOfflineMediaKeys(licenseIdVec); - EXPECT_NE(result, DRM_ERR_OK); - result = sessionObject->sessionImpl_->ClearMediaKeys(); - EXPECT_NE(result, DRM_ERR_OK); - std::string mimeType; - bool status; - result = sessionObject->sessionImpl_->RequireSecureDecoderModule(mimeType, &status); - EXPECT_NE(result, DRM_ERR_OK); - } - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -static void killclearplay2(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - bool supported = true; - supported = OH_MediaKeySystem_IsSupported(GetUuid()); - EXPECT_EQ(supported, true); - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "video/mp4"); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - - errNo = - OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); - EXPECT_NE(errNo, DRM_ERR_OK); - char value[32]; - int32_t valueLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, - sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char configByteArray[32]; - int32_t byteArrayLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, - &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_Statistics statistics; - errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackWithObject_084, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetCallback(mediaKeySystem, &TestSystemEventCallBackWithObj); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback callback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &callback); - EXPECT_EQ(errNo, DRM_ERR_OK); - OH_MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBackWithObj, - &TestSessoinKeyChangeCallBackWithObj }; - errNo = OH_MediaKeySession_SetCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[2] = {0x07, 0x22}; - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_KillClearPlayHostAbNormal1, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char request[12288] = { 0 }; // 12288:request len - int32_t requestLen = 12288; // 12288:request len - char defaultUrl[2048] = { 0 }; // 2048:url len - int32_t defaultUrlLen = 2048; // 2048:url len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, - defaultUrlLen); - unsigned char KeySystemResponse[12288] = OFFRESPONSE; - int32_t KeySystemResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(PROVISION_URL, request, requestLen, KeySystemResponse, &KeySystemResponseLen, 10); - EXPECT_EQ(rett, 0); - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - KeySystemResponseLen = 50; - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - killclearplay(mediaKeySystem, mediaKeySession); - sleep(5); - killclearplay2(mediaKeySystem, mediaKeySession); - requestLen = 12288; // 12288:request len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, - defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); - sleep(5); -} - -static void PrepareCryptoInfo_HugeSubsample(CryptInfo &info) -{ - info.type = CryptAlgorithmType::ALGTYPE_AES_CTR; - info.pattern.encryptBlocks = 0; - info.pattern.skipBlocks = 0; - SubSample testSubsample; - testSubsample.clearHeaderLen = 3 * 1024 * 1024; // 1024 = 1kb 3M - testSubsample.payLoadLen = 1 * 1024 * 1024; // 1024 = 1kb 1M - info.subSample.push_back(testSubsample); - testSubsample.clearHeaderLen = 1 * 1024 * 1024; // 1024 = 1kb 1M - testSubsample.payLoadLen = 3 * 1024 * 1024; // 1024 = 1kb 3M - info.subSample.push_back(testSubsample); - testSubsample.clearHeaderLen = 1024; // 1024 = 1kb - testSubsample.payLoadLen = 1024; // 1024 = 1kb - info.subSample.push_back(testSubsample); - testSubsample.clearHeaderLen = 1024; // 1024 = 1kb - testSubsample.payLoadLen = 1024; // 1024 = 1kb - info.subSample.push_back(testSubsample); - testSubsample.clearHeaderLen = 1024; // 1024 = 1kb - testSubsample.payLoadLen = 507 * 1024; // 1024 = 1kb 507kb - info.subSample.push_back(testSubsample); - testSubsample.clearHeaderLen = 24; // 24 = 16 + 8 - testSubsample.payLoadLen = 2 * 1024 * 1024; // 1024 = 1kb 2M - info.subSample.push_back(testSubsample); - testSubsample.clearHeaderLen = 1024; // 1024 = 1kb - testSubsample.payLoadLen = 0; - info.subSample.push_back(testSubsample); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_Dump_01, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sptr SessionServiceProxy = - sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy(); - sptr decryptModule; - SessionServiceProxy->GetMediaDecryptModule(decryptModule); - MessageParcel data; - DrmBuffer srcBuffer; - DrmBuffer dstBuffer; - bool secureDecodrtState = false; - CryptInfo cryptInfo; - decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); - decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); - decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); - PrepareCryptoInfo_HugeSubsample(cryptInfo); - decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); - system("hidumper -s 3012"); - decryptModule->Release(); - } - - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystem_MAX_01, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - const uint32_t maxNum = 64; - std::vector systems(maxNum, nullptr); - const char *name = GetUuid(); - for (uint i = 0; i < maxNum; i++) { - errNo = OH_MediaKeySystem_Create(name, &systems[i]); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_NE(systems[i], nullptr); - } - - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(name, &mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_MAX_SYSTEM_NUM_REACHED); - EXPECT_EQ(mediaKeySystem, nullptr); - - for (uint i = 0; i < maxNum; i++) { - errNo = OH_MediaKeySystem_Destroy(systems[i]); - systems[i] = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); - } -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySession_MAX_01, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - const uint32_t maxNum = 64; - std::vector sessions(maxNum, nullptr); - - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - for (uint i = 0; i < maxNum; i++) { - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &sessions[i]); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_NE(sessions[i], nullptr); - } - - MediaKeySession *mediaKeySession = nullptr; - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_MAX_SESSION_NUM_REACHED); - EXPECT_EQ(mediaKeySession, nullptr); - - for (uint i = 0; i < maxNum; i++) { - errNo = OH_MediaKeySession_Destroy(sessions[i]); - sessions[i] = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); - } - - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -} // DrmStandard -} // OHOS +/* + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. + * 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 +#include +#include +#include +#include "cstdio" +#include "cstdlib" +#include +#include "native_drm_common.h" +#include "native_drm_err.h" +#include "gmock/gmock.h" +#include "native_drm_base.h" +#include "native_drm_object.h" +#include "imedia_decrypt_module_service.h" +#include "native_mediakeysession.h" +#include "native_mediakeysystem.h" +#include "cstdbool" +#include "drm_types.h" +#include "drm_framework_unittest.h" +#include "drm_log.h" +#include "drm_death_recipient.h" +#include "key_session_impl.h" +#include "imedia_key_system_service.h" +#include "media_key_system_factory_impl.h" +#include "media_key_system_service_callback_stub.h" +#include "http.h" +#include "ashmem.h" +#include "media_decrypt_module_service_proxy.h" +#include +#include +#include +#include "nocopyable.h" +#include "ipc_skeleton.h" +#include "imedia_key_session_service.h" +#include "imedia_key_session_service_callback.h" +#include "media_key_session_service_callback_stub.h" +#include "drm_common_utils.h" + + +#define DRM_SAMPLE_CHECK_AND_RETURN_RET_LOG(cond, ret, fmt, ...) \ + do { \ + if ((cond)) { \ + printf(fmt, ##__VA_ARGS__); \ + return ret; \ + } \ + } while (0) +#define DRM_SAMPLE_INFO_LOG(fmt, ...) fprintf(stdout, "[INFO] " fmt "\n", ##__VA_ARGS__) +#define DRM_SAMPLE_ERROR_LOG(fmt, ...) fprintf(stdout, "[ERROR] " fmt "\n", ##__VA_ARGS__) +#define OFFRESPONSE \ + { \ + 0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, \ + 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, \ + 0x4E, 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, \ + 0x48, 0x64, 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, \ + 0x34, 0x5A, 0x48, 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D \ + } +#define REQUESTINFODATA \ + { \ + 0x00, 0x00, 0x00, 0x8B, 0x70, 0x73, 0x73, 0x68, 0x00, 0x00, 0x00, \ + 0x00, 0x3D, 0x5E, 0x6D, 0x35, 0x9B, 0x9A, 0x41, 0xE8, 0xB8, \ + 0x43, 0xDD, 0x3C, 0x6E, 0x72, 0xC4, 0x2C, 0x00, 0x00, 0x00, \ + 0x6B, 0x7B, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, \ + 0x22, 0x3A, 0x22, 0x56, 0x31, 0x2E, 0x30, 0x22, 0x2C, 0x22, \ + 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x22, \ + 0x3A, 0x22, 0x64, 0x48, 0x4D, 0x74, 0x4D, 0x6A, 0x59, 0x30, \ + 0x4C, 0x54, 0x45, 0x77, 0x4F, 0x44, 0x41, 0x74, 0x59, 0x57, \ + 0x56, 0x7A, 0x22, 0x2C, 0x22, 0x6B, 0x69, 0x64, 0x73, 0x22, \ + 0x3A, 0x5B, 0x22, 0x47, 0x2B, 0x45, 0x6B, 0x2F, 0x2B, 0x58, \ + 0x6D, 0x55, 0x6B, 0x70, 0x42, 0x48, 0x51, 0x67, 0x58, 0x59, \ + 0x57, 0x51, 0x51, 0x49, 0x67, 0x3D, 0x3D, 0x22, 0x5D, 0x2C, \ + 0x22, 0x65, 0x6E, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x22, \ + 0x3A, 0x22, 0x63, 0x62, 0x63, 0x31, 0x22, 0x7D \ + } +#define OFFREQUESTINFODATA \ + { \ + 0x00, 0x00, 0x00, 0x8b, 0x70, 0x73, 0x73, 0x68, 0x00, 0x00, 0x00, \ + 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, \ + 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x00, \ + 0x6b, 0x7b, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, \ + 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, \ + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, \ + 0x3a, 0x22, 0x64, 0x48, 0x4d, 0x74, 0x4d, 0x6a, 0x59, 0x30, \ + 0x4c, 0x54, 0x45, 0x77, 0x4f, 0x44, 0x41, 0x74, 0x59, 0x57, \ + 0x56, 0x7a, 0x22, 0x2c, 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, \ + 0x3a, 0x5b, 0x22, 0x47, 0x2b, 0x45, 0x6b, 0x2f, 0x2b, 0x58, \ + 0x6d, 0x55, 0x6b, 0x70, 0x42, 0x48, 0x51, 0x67, 0x58, 0x59, \ + 0x57, 0x51, 0x51, 0x49, 0x67, 0x3d, 0x3d, 0x22, 0x5d, 0x2c, \ + 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, \ + 0x3a, 0x22, 0x63, 0x62, 0x63, 0x31, 0x22, 0x7d \ + } +#define ONRESPONSE \ + { \ + 0x30, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, \ + 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, \ + 0x4E, 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, \ + 0x48, 0x64, 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, \ + 0x34, 0x5A, 0x48, 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D \ + } + + +#define LICENSE_URL "http://license.dev.trustdta.com:8080/drmproxy/v3/getLicense" +#define PROVISION_URL "https://wiseplay-prv.cloud.huawei.com/provision/v1/wiseplay" +using namespace testing::ext; +using namespace std; + +namespace { +const int32_t STEP_ONE = 1; +const int32_t STEP_TWO = 2; +const int32_t STEP_THREE = 3; +const int32_t STEP_FOUR = 4; +} + +namespace OHOS { +namespace DrmStandard { + +bool g_isWisePlay = false; +void DrmFrameworkUnitTest::SetUpTestCase(void) {} + +void DrmFrameworkUnitTest::TearDownTestCase(void) {} + +static const char *GetUuid() +{ + if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) { + return "com.clearplay.drm"; + } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) { + return "com.wiseplay.drm"; + } else { + return "ERROR"; + } +} + +void DrmFrameworkUnitTest::SetUp() +{ + if (strcmp(GetUuid(), "com.wiseplay.drm") == 0) { + g_isWisePlay = true; + } + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char request[12288] = { 0 }; // 12288:request len + int32_t requestLen = 12288; // 12288:request len + char defaultUrl[2048] = { 0 }; // 2048:url len + int32_t defaultUrlLen = 2048; // 2048:url len + DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; + errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (certStatus == CERT_STATUS_NOT_PROVISIONED) { + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, + defaultUrlLen); + unsigned char KeySystemResponse[12288] = OFFRESPONSE; + int32_t KeySystemResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(PROVISION_URL, request, requestLen, KeySystemResponse, &KeySystemResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + KeySystemResponseLen = 50; // 50 is the length of system response + } + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; +} + +void DrmFrameworkUnitTest::TearDown() {} + +static const char *GetDrmPlugin() +{ + if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) { + return "killall -9 clearplay_host"; + } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) { + return "killall -9 wiseplay_host"; + } else { + return "ERROR"; + } +} + +Drm_ErrCode TestSystemEventCallBack(DRM_EventType eventType, unsigned char *info, + int32_t infoLen, char *extra) +{ + DRM_SAMPLE_INFO_LOG("TestSystemEventCallBack ok"); + return DRM_ERR_OK; +} + +Drm_ErrCode TestSessoinEventCallBack(DRM_EventType eventType, unsigned char *info, + int32_t infoLen, char *extra) +{ + DRM_SAMPLE_INFO_LOG("TestSessoinEventCallBack ok"); + return DRM_ERR_OK; +} + +Drm_ErrCode TestSessoinKeyChangeCallBack(DRM_KeysInfo *keysInfo, bool hasNewGoodKeys) +{ + DRM_SAMPLE_INFO_LOG("TestSessoinKeyChangeCallBack ok"); + return DRM_ERR_OK; +} + +Drm_ErrCode TestSystemEventCallBackWithObj(MediaKeySystem *mediaKeySystem, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra) +{ + DRM_SAMPLE_INFO_LOG("TestSystemEventCallBackWithObj ok"); + if (mediaKeySystem == nullptr) { + return DRM_ERR_UNKNOWN; + } + DRM_SAMPLE_INFO_LOG("Event: event type: %d", eventType); + DRM_SAMPLE_INFO_LOG("Event: the info body is: "); + if (info != nullptr) { + for (int32_t i = 0; i < infoLen; i++) { + DRM_SAMPLE_INFO_LOG("%x", info[i]); + } + } + if (extra != nullptr) { + DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra); + } + return DRM_ERR_OK; +} + +Drm_ErrCode TestSessoinEventCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra) +{ + DRM_SAMPLE_INFO_LOG("TestSessoinEventCallBackWithObj ok"); + if (mediaKeySessoin == nullptr) { + return DRM_ERR_UNKNOWN; + } + DRM_SAMPLE_INFO_LOG("Event: the event type: %d", eventType); + DRM_SAMPLE_INFO_LOG("Event: the info body is: "); + if (info != nullptr) { + for (int32_t i = 0; i < infoLen; i++) { + DRM_SAMPLE_INFO_LOG("%x", info[i]); + } + } + if (extra != nullptr) { + DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra); + } + return DRM_ERR_OK; +} + +Drm_ErrCode TestSessoinKeyChangeCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_KeysInfo *keysInfo, + bool hasNewGoodKeys) +{ + DRM_SAMPLE_INFO_LOG("TestSessoinKeyChangeCallBackWithObj ok"); + if (mediaKeySessoin == nullptr) { + return DRM_ERR_UNKNOWN; + } + for (uint32_t i = 0; i < keysInfo->keysInfoCount; i++) { + for (uint32_t j = 0; j < MAX_KEY_ID_LEN; j += STEP_FOUR) { + DRM_SAMPLE_INFO_LOG("KeyChangedEvent: keyid is: "); + DRM_SAMPLE_INFO_LOG("%x %x %x %x", + keysInfo->keyId[i][j], keysInfo->keyId[i][j + STEP_ONE], + keysInfo->keyId[i][j + STEP_TWO], keysInfo->keyId[i][j + STEP_THREE]); + } + DRM_SAMPLE_INFO_LOG("KeyChangedEvent: statusValue %s", keysInfo->statusValue[i]); + } + return DRM_ERR_OK; +} + +/* + * Feature: Framework + * Function: Test to determine if the creation of this DRM instance is supported + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedNormal_001, TestSize.Level0) +{ + bool supported; + supported = OH_MediaKeySystem_IsSupported(GetUuid()); + EXPECT_EQ(supported, true); +} + +/* + * Feature: Framework + * Function: Test to determine if the creation of this DRM instance is supported + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2Normal_002, TestSize.Level0) +{ + bool supported; + supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "video/mp4"); + EXPECT_EQ(supported, true); +} + +/* + * Feature: Framework + * Function: Test to determine if the creation of this DRM instance is supported + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3Normal_003, TestSize.Level0) +{ + bool supported; + supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + EXPECT_EQ(supported, true); +} + +/* + * Feature: Framework + * Function: Test to determine if the creation of this DRM instance is supported + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedAbNormal_004, TestSize.Level0) +{ + bool supported = true; + supported = OH_MediaKeySystem_IsSupported("com.drm.clearpla"); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported(""); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported(nullptr); + EXPECT_EQ(supported, false); +} + +/* + * Feature: Framework + * Function: Test to determine if the creation of this DRM instance is supported + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2AbNormal_005, TestSize.Level0) +{ + bool supported = true; + supported = OH_MediaKeySystem_IsSupported2("com.drm.clearpla", "video/mp4"); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported2("", "video/mp4"); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported2(nullptr, "video/mp4"); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "ideo/mp4"); + if (g_isWisePlay) { + EXPECT_EQ(supported, true); + } else { + EXPECT_EQ(supported, false); + } + supported = OH_MediaKeySystem_IsSupported2(GetUuid(), ""); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported2(GetUuid(), nullptr); + EXPECT_EQ(supported, false); +} + +/* + * Feature: Framework + * Function: Test to determine if the creation of this DRM instance is supported + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3AbNormal_006, TestSize.Level0) +{ + bool supported = true; + supported = OH_MediaKeySystem_IsSupported3("com.drm.clearpla", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported3("", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported3(nullptr, "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "ideo/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + if (g_isWisePlay) { + EXPECT_EQ(supported, true); + } else { + EXPECT_EQ(supported, false); + } + supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported3(GetUuid(), nullptr, CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", + (DRM_ContentProtectionLevel)(CONTENT_PROTECTION_LEVEL_UNKNOWN - 1)); + EXPECT_EQ(supported, false); + supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", + (DRM_ContentProtectionLevel)CONTENT_PROTECTION_LEVEL_MAX); + EXPECT_EQ(supported, false); +} + +/* + * Feature: Framework + * Function: Test and create DRM instances + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Test Creating DRM Instance + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_007, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_GT(contentProtectionLevel, 0); + if (mediaKeySystem != nullptr) { + OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + } +} + +/* + * Feature: Framework + * Function: Test and create DRM instances + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Testing for an incorrect uuid and unsuccessful creation of DRM instance. + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_008, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySystem_Create("com.drm.clerpay", &mediaKeySystem); + EXPECT_EQ(mediaKeySystem, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Test and create DRM instances + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Test passed in an empty uuid and failed to create a DRM instance. + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_009, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySystem_Create("", &mediaKeySystem); + EXPECT_EQ(mediaKeySystem, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Test and create DRM instances + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: After the DRM instance is created, it is destroyed, and then the subsequent interface is called. + * The interface returns unsuccessful. + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_010, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); + mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Test and create sessions + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Test Creating Sessions + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionNormal_011, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Test that the RequireSecureDecoderModule interface is functioning properly + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: Testing that the RequireSecureDecoderModule interface is functioning properly + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleNormal_012, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + bool requireSecureDecoder; + errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: RequireSecureDecoderModule Exception Test + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_013, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + bool requireSecureDecoder = false; + errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "asdssadadsa", &requireSecureDecoder); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(requireSecureDecoder, false); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: RequireSecureDecoderModule Exception Test + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_014, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + bool requireSecureDecoder = false; + errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "", &requireSecureDecoder); + EXPECT_NE(errNo, DRM_ERR_OK); + EXPECT_EQ(requireSecureDecoder, false); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: RequireSecureDecoderModule Exception Test + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_015, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + bool requireSecureDecoder = false; + errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, nullptr, &requireSecureDecoder); + EXPECT_NE(errNo, DRM_ERR_OK); + EXPECT_EQ(requireSecureDecoder, false); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: RequireSecureDecoderModule Exception Test + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_016, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: RequireSecureDecoderModule Exception Test + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_017, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + bool requireSecureDecoder = false; + errNo = OH_MediaKeySession_RequireSecureDecoderModule(nullptr, "video/mp4", &requireSecureDecoder); + EXPECT_NE(errNo, DRM_ERR_OK); + EXPECT_EQ(requireSecureDecoder, false); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: GenerateKeySystemRequest normal testing to obtain normal requests + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case description: GenerateKeySystemRequest obtained a normal request through normal testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestNormal_018, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: GenerateKeySystemRequest parameter exception testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: GenerateKeySystemRequest Parameter Exception Test + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestAbNormal_019, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char request[12288] = { 0 }; // 12288:request len + int32_t requestLen = 12288; // 12288:request len + char defaultUrl[2048] = { 0 }; // 2048:url len + int32_t defaultUrlLen = 2048; // 2048:url len + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(nullptr, request, &requestLen, defaultUrl, defaultUrlLen); + EXPECT_NE(errNo, DRM_ERR_OK); + requestLen = 12288; // 12288:request len + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, nullptr, &requestLen, defaultUrl, + defaultUrlLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, nullptr, defaultUrl, defaultUrlLen); + EXPECT_NE(errNo, DRM_ERR_OK); + requestLen = 12288; // 12288:request len + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, nullptr, defaultUrlLen); + EXPECT_NE(errNo, DRM_ERR_OK); + requestLen = 12288; // 12288:request len + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_020, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_021, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char KeySystemResponse[12288] = OFFRESPONSE; + int32_t KeySystemResponseLen = 12288; + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(nullptr, KeySystemResponse, KeySystemResponseLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_022, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + int32_t KeySystemResponseLen = 12288; + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, nullptr, KeySystemResponseLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_023, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestNormal_024, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_025, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(nullptr, &info, &mediaKeyRequest); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_026, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, nullptr, &mediaKeyRequest); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_027, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + } + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_029, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[1] = { 0 }; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(nullptr, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_030, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[1] = { 0 }; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, nullptr, 0, + onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_031, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testKeySessionResponse[50] = OFFRESPONSE; + int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)(sizeof(testKeySessionResponse)), nullptr, &onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_032, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusNormal_033, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + unsigned char testData[139] = REQUESTINFODATA; + info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = sizeof(testData); + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + } + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(nullptr, &mediaKeyStatus); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + + errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + if (g_isWisePlay) { + EXPECT_EQ(errNo, DRM_ERR_OK); + } else { + EXPECT_NE(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_037, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + errNo = OH_MediaKeySession_ClearMediaKeys(nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusNormal_038, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, info.initDataLen); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + } + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_039, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_040, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, nullptr, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_041, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsNormal_042, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediakeyIdArray offlineMediaKeyIds; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_043, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediakeyIdArray offlineMediaKeyIds; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(nullptr, &offlineMediaKeyIds); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_044, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestNormal_045, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestAbNormal_046, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + nullptr, &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseNormal_047, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + if (!g_isWisePlay) { + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_048, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusNormal_049, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; + errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); + EXPECT_EQ(certStatus, 0); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusAbNormal_050, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; + errNo = OH_MediaKeySystem_GetCertificateStatus(nullptr, &certStatus); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringNormal_051, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = + OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); + if (g_isWisePlay) { + EXPECT_NE(errNo, DRM_ERR_OK); + } else { + EXPECT_EQ(errNo, DRM_ERR_OK); + } + char value[32]; + int32_t valueLen = 32; + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "version", value, valueLen); + if (g_isWisePlay) { + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "version", value, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + } else { + EXPECT_NE(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 10); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringAbNormal_052, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationString(nullptr, "testConfigurationString", "gezhegezhegezhe"); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "", "gezhegezhegezhe"); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, nullptr, "gezhegezhegezhe"); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", ""); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationStringAbNormal_053, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "gezhegezhegezhe"); + if (g_isWisePlay) { + EXPECT_NE(errNo, DRM_ERR_OK); + } else { + EXPECT_EQ(errNo, DRM_ERR_OK); + } + char value[32]; + int32_t valueLen = 32; + errNo = OH_MediaKeySystem_GetConfigurationString(nullptr, "testConfigurationString", value, valueLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "", value, valueLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, nullptr, value, valueLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr, valueLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayNormal_054, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testArray[5] = {1, 2, 3, 4, 5}; + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, + sizeof(testArray)); + if (g_isWisePlay) { + EXPECT_NE(errNo, DRM_ERR_OK); + } else { + EXPECT_EQ(errNo, DRM_ERR_OK); + } + unsigned char configByteArray[128]; + int32_t byteArrayLen = 128; + errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "deviceUniqueId", configByteArray, + &byteArrayLen); + if (g_isWisePlay) { + EXPECT_EQ(errNo, DRM_ERR_OK); + } else { + EXPECT_NE(errNo, DRM_ERR_OK); + } + + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationByteArrayAbNormal_055, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testArray[5] = {1, 2, 3, 4, 5}; + errNo = OH_MediaKeySystem_SetConfigurationByteArray(nullptr, "testConfigurationByteArray", testArray, + sizeof(testArray)); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "", testArray, sizeof(testArray)); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, nullptr, testArray, sizeof(testArray)); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr, + sizeof(testArray)); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayAbNormal_056, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testArray[5] = {1, 2, 3, 4, 5}; + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, + sizeof(testArray)); + unsigned char configByteArray[32]; + int32_t byteArrayLen = 32; + errNo = OH_MediaKeySystem_GetConfigurationByteArray(nullptr, "testConfigurationByteArray", configByteArray, + &byteArrayLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "", configByteArray, &byteArrayLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, nullptr, configByteArray, &byteArrayLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr, + &byteArrayLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, + nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsNormal_057, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_Statistics statistics; + errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsAbNormal_058, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_Statistics statistics; + errNo = OH_MediaKeySystem_GetStatistics(nullptr, &statistics); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Test and create DRM instances + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Test Creating DRM Instance + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetMaxContentProtectionLevelAbNormal_059, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(nullptr, &contentProtectionLevel); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + if (mediaKeySystem != nullptr) { + OH_MediaKeySystem_Destroy(mediaKeySystem); + } +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysNormal_060, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysAbNormal_061, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (!g_isWisePlay) { + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysNormal_062, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (!g_isWisePlay) { + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} +/* + * Feature: Framework + * Function: Processing device certificate response testing + * Sub function: NA + * Function point: NA + * Environmental conditions: NA + * Case Description: Processing Device Certificate Response Testing + */ +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_063, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = 139; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, 139, testData, 139); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (!g_isWisePlay) { + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +#define MAX_BUFF 139 +static void filldata(DRM_MediaKeyRequestInfo *info) +{ + unsigned char testData[139] = REQUESTINFODATA; + memset_s(info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info->initDataLen = sizeof(testData); + info->type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info->mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info->initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info->optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info->optionData[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + info->optionsCount = 1; +} + +const unsigned char TESTKEYRELEASERESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, + 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, + 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, + 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, + 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; +const unsigned char TESTKEYSESSIONRESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, + 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, + 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, + 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, + 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; + +static void filltest3(MediaKeySystem *mediaKeySystem, + MediaKeySession *mediaKeySession, unsigned char *keySystemResponse, int32_t KeySystemResponseLen) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, keySystemResponse, + KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + if (!g_isWisePlay) { + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + (uint8_t *)(TESTKEYRELEASERESPONSE), (int32_t)(sizeof(TESTKEYRELEASERESPONSE))); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GetContentProtectionLevel(nullptr, &sessionContentProtectionLevel); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_064, TestSize.Level0) +{ + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + int32_t KeySystemResponseLen = 12288; + unsigned char KeySystemResponse[12288] = OFFRESPONSE; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + KeySystemResponseLen = 50; + } + EXPECT_EQ(errNo, DRM_ERR_OK); + filltest3(mediaKeySystem, mediaKeySession, KeySystemResponse, KeySystemResponseLen); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + mediaKeySession = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + mediaKeySession = nullptr; + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_065, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_066, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + } + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + sptr SessionServiceProxy = + sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy(); + sptr decryptModule; + SessionServiceProxy->GetMediaDecryptModule(decryptModule); + MessageParcel data; + DrmBuffer srcBuffer; + DrmBuffer dstBuffer; + bool secureDecodrtState = false; + CryptInfo cryptInfo; + decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); + decryptModule->Release(); + sptr callback = sessionObject->sessionImpl_->GetApplicationCallback(); + callback->~MediaKeySessionImplCallback(); + } + if (mediaKeySystem) { + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + sptr serviceCallback = + new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_); + sptr Callback = new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_); + const std::vector data = { 0x01 }; + MessageParcel data1; + MessageParcel reply; + MessageOption option; + data1.WriteInt32(static_cast(OHOS::DrmStandard::DrmEventType::DRM_EVENT_PROVISION_REQUIRED)); + data1.WriteInt32(1); + data1.WriteInt32(data.size()); + for (auto it = data.begin(); it != data.end(); ++it) { + int32_t ret = data1.WriteUint8((*it)); + EXPECT_NE(ret, 0); + } + Callback->OnRemoteRequest(static_cast(IMediaKeySystemServiceCallbackIpcCode::COMMAND_SEND_EVENT), + data1, reply, option); + serviceCallback->SendEvent(OHOS::DrmStandard::DrmEventType::DRM_EVENT_PROVISION_REQUIRED, 1, data); + OHOS::sptr SystemCallbackCapi = + new (std::nothrow) MediaKeySystemCallbackCapi(); + SystemCallbackCapi->SetCallbackReference(&TestSystemEventCallBack); + SystemCallbackCapi->SendEvent("1", 1, data); + sptr SystemImplCallba = systemObject->systemImpl_->GetApplicationCallback(); + SystemImplCallba->~MediaKeySystemImplCallback(); + } + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_067, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + int32_t releaseRequestLen = 12288; // 12288:request len + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + uint8_t mediaKeyIdToRelease; + MediaKeySession *mediaKeySession = (MediaKeySession *)&mediaKeyIdToRelease; + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, 11, releaseRequest, // 11:len + &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)&releaseRequestLen, 0, + releaseRequest, &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, 0, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, 11, // 11:len + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, + 11, nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, + 11, testKeyReleaseResponse, 0); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_068, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + unsigned char onlineMediaKeyId[88]; // 88:keyId len + uint32_t onlineMediaKeyIdLen = 88; // 88:keyId len + MediaKeySession *mediaKeySession = (MediaKeySession *)&onlineMediaKeyId; + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetMediaKeySessionCallbackNormal_069, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // test 3: system callback + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(nullptr, &TestSystemEventCallBack); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(nullptr, &sessionCallback); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_070, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(nullptr, &mediaKeySystem); + EXPECT_EQ(mediaKeySystem, nullptr); + errNo = OH_MediaKeySystem_Create(GetUuid(), nullptr); + EXPECT_EQ(mediaKeySystem, nullptr); + errNo = OH_MediaKeySystem_CreateMediaKeySession(nullptr, &contentProtectionLevel, &mediaKeySession); + EXPECT_EQ(mediaKeySession, nullptr); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, nullptr, &mediaKeySession); + EXPECT_EQ(mediaKeySession, nullptr); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, nullptr); + EXPECT_EQ(mediaKeySession, nullptr); + uint8_t mediaKeyIdToClear; + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&mediaKeyIdToClear, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, 11); // 11:len + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemDestroyAbNormal_071, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySystem) { + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + systemObject->systemImpl_->~MediaKeySystemImpl(); + } + errNo = + OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); + EXPECT_NE(errNo, DRM_ERR_OK); + char value[32]; + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 32); + EXPECT_NE(errNo, DRM_ERR_OK); + unsigned char testArray[5] = {1, 2, 3, 4, 5}; + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, + sizeof(testArray)); + EXPECT_NE(errNo, DRM_ERR_OK); + unsigned char configByteArray[32]; + int32_t byteArrayLen = 32; + errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, + &byteArrayLen); + EXPECT_NE(errNo, DRM_ERR_OK); + DRM_Statistics statistics; + errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); + EXPECT_NE(errNo, DRM_ERR_OK); + contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_OH_MediaKeySystemDestroyAbNormal2_072, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySystem) { + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + systemObject->systemImpl_->~MediaKeySystemImpl(); + } + DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; + errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + MediaKeySession *OH_MediaKeySession2 = nullptr; + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &OH_MediaKeySession2); + EXPECT_EQ(OH_MediaKeySession2, nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); + DRM_OfflineMediakeyIdArray offlineMediaKeyIds; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1, + &OfflineMediaKeyStatus); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal_073, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + sessionObject->sessionImpl_->~MediaKeySessionImpl(); + } + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal2_074, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + sessionObject->sessionImpl_->~MediaKeySessionImpl(); + } + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = { 0 }; + int32_t testKeySessionResponseLen = 12288; + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySession_DestroyAbNormal3_075, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + sessionObject->sessionImpl_->~MediaKeySessionImpl(); + } + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); + EXPECT_NE(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)GetUuid(), + 11, releaseRequest, &releaseRequestLen); // 11:len + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal4_076, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + sessionObject->sessionImpl_->~MediaKeySessionImpl(); + } + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)GetUuid(), + 11, testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, (unsigned char *)GetUuid(), 1); + EXPECT_NE(errNo, DRM_ERR_OK); + DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel); + EXPECT_NE(errNo, DRM_ERR_OK); + bool requireSecureDecoder; + errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal_077, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen, + testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0);} else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal2_078, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[2] = {0x07, 0x22}; + int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_079, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen, + testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)("onlineMediaKeyId"), + 2, releaseRequest, &releaseRequestLen); // 2:len + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_080, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t KeySystemResponseLen = 12288; + unsigned char KeySystemResponse[12288] = OFFRESPONSE; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + KeySystemResponseLen = 50; + } + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, KeySystemResponse, + KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testKeyReleaseResponse[2] = {0x33, 0x22}; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); +} + +static void filltest(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, (uint8_t *)TESTKEYSESSIONRESPONSE, + (int32_t)(sizeof(TESTKEYSESSIONRESPONSE)), onlineMediaKeyId, &onlineMediaKeyIdLen); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + (uint8_t *)TESTKEYRELEASERESPONSE, (int32_t)(sizeof(TESTKEYRELEASERESPONSE))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, (unsigned char *)"onlineMediaKeyId", 1); + EXPECT_NE(errNo, DRM_ERR_OK); +} +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_081, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + filltest(mediaKeySystem, mediaKeySession); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); + sleep(1); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_082, TestSize.Level0) +{ + MediaKeySystem *mediaKeySystem = nullptr; + string name; + string uuid; + Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (mediaKeySystem) { + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + ContentProtectionLevel securityLevel = + ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + OHOS::sptr keySessionImpl = nullptr; + systemObject->systemImpl_->~MediaKeySystemImpl(); + systemObject->systemImpl_->CreateMediaKeySession(securityLevel, &keySessionImpl); + keySessionImpl = nullptr; + MediaKeySystemCallback *allback = new MediaKeySystemCallback(); + allback->~MediaKeySystemCallback(); + OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); + fatory->Init(); + if (g_isWisePlay) { + name = "com.wiseplay.drm"; + } else { + name = "com.wiseplay.drm"; + } + fatory->GetMediaKeySystemUuid(name, uuid); + name = "com.test"; + fatory->GetMediaKeySystemUuid(name, uuid); + } + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_NE(errNo, DRM_ERR_OK); + MediaKeySystem *mediaKeySystem2 = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem2); + EXPECT_NE(mediaKeySystem2, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem2); + mediaKeySystem2 = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SessionImplAbNormal_083, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 50; + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + MediaKeySessionServiceCallback *Object = new MediaKeySessionServiceCallback(sessionObject->sessionImpl_); + std::map, MediaKeySessionKeyStatus> statusTable = { { { 0x01 }, + MediaKeySessionKeyStatus::MEDIA_KEY_SESSION_KEY_STATUS_USABLE } }; + bool hasNewGoodLicense = false; + Object->SendEventKeyChanged(statusTable, hasNewGoodLicense); + } + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +static void killclearplay(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + std::vector licenseIdVec = { 0x01 }; + std::vector ReleaseRequest = { 0x01 }; + ContentProtectionLevel securityLevel; + system(GetDrmPlugin()); + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + uint32_t result = sessionObject->sessionImpl_->GenerateOfflineReleaseRequest(licenseIdVec, ReleaseRequest); + EXPECT_NE(result, DRM_ERR_OK); + result = sessionObject->sessionImpl_->ProcessOfflineReleaseResponse(licenseIdVec, ReleaseRequest); + EXPECT_NE(result, DRM_ERR_OK); + result = sessionObject->sessionImpl_->GetContentProtectionLevel(&securityLevel); + EXPECT_NE(result, DRM_ERR_OK); + std::map licenseStatus2; + result = sessionObject->sessionImpl_->CheckMediaKeyStatus(licenseStatus2); + EXPECT_NE(result, DRM_ERR_OK); + result = sessionObject->sessionImpl_->RestoreOfflineMediaKeys(licenseIdVec); + EXPECT_NE(result, DRM_ERR_OK); + result = sessionObject->sessionImpl_->ClearMediaKeys(); + EXPECT_NE(result, DRM_ERR_OK); + std::string mimeType; + bool status; + result = sessionObject->sessionImpl_->RequireSecureDecoderModule(mimeType, &status); + EXPECT_NE(result, DRM_ERR_OK); + } + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +static void killclearplay2(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + bool supported = true; + supported = OH_MediaKeySystem_IsSupported(GetUuid()); + EXPECT_EQ(supported, true); + supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "video/mp4"); + supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); + + errNo = + OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); + EXPECT_NE(errNo, DRM_ERR_OK); + char value[32]; + int32_t valueLen = 32; + errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, valueLen); + EXPECT_NE(errNo, DRM_ERR_OK); + unsigned char testArray[5] = {1, 2, 3, 4, 5}; + errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, + sizeof(testArray)); + EXPECT_NE(errNo, DRM_ERR_OK); + unsigned char configByteArray[32]; + int32_t byteArrayLen = 32; + errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, + &byteArrayLen); + EXPECT_NE(errNo, DRM_ERR_OK); + DRM_Statistics statistics; + errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); + EXPECT_NE(errNo, DRM_ERR_OK); + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); + EXPECT_NE(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackWithObject_084, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetCallback(mediaKeySystem, &TestSystemEventCallBackWithObj); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + MediaKeySession_Callback callback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &callback); + EXPECT_EQ(errNo, DRM_ERR_OK); + OH_MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBackWithObj, + &TestSessoinKeyChangeCallBackWithObj }; + errNo = OH_MediaKeySession_SetCallback(mediaKeySession, &sessionCallback); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[2] = {0x07, 0x22}; + int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_KillClearPlayHostAbNormal1, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char request[12288] = { 0 }; // 12288:request len + int32_t requestLen = 12288; // 12288:request len + char defaultUrl[2048] = { 0 }; // 2048:url len + int32_t defaultUrlLen = 2048; // 2048:url len + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, + defaultUrlLen); + unsigned char KeySystemResponse[12288] = OFFRESPONSE; + int32_t KeySystemResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(PROVISION_URL, request, requestLen, KeySystemResponse, &KeySystemResponseLen, 10); + EXPECT_EQ(rett, 0); + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); + EXPECT_NE(errNo, DRM_ERR_OK); + } else { + KeySystemResponseLen = 50; + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + killclearplay(mediaKeySystem, mediaKeySession); + sleep(5); + killclearplay2(mediaKeySystem, mediaKeySession); + requestLen = 12288; // 12288:request len + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, + defaultUrlLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); + EXPECT_NE(errNo, DRM_ERR_OK); + DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; + errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); + sleep(5); +} + +static void PrepareCryptoInfo_HugeSubsample(CryptInfo &info) +{ + info.type = CryptAlgorithmType::ALGTYPE_AES_CTR; + info.pattern.encryptBlocks = 0; + info.pattern.skipBlocks = 0; + SubSample testSubsample; + testSubsample.clearHeaderLen = 3 * 1024 * 1024; // 1024 = 1kb 3M + testSubsample.payLoadLen = 1 * 1024 * 1024; // 1024 = 1kb 1M + info.subSample.push_back(testSubsample); + testSubsample.clearHeaderLen = 1 * 1024 * 1024; // 1024 = 1kb 1M + testSubsample.payLoadLen = 3 * 1024 * 1024; // 1024 = 1kb 3M + info.subSample.push_back(testSubsample); + testSubsample.clearHeaderLen = 1024; // 1024 = 1kb + testSubsample.payLoadLen = 1024; // 1024 = 1kb + info.subSample.push_back(testSubsample); + testSubsample.clearHeaderLen = 1024; // 1024 = 1kb + testSubsample.payLoadLen = 1024; // 1024 = 1kb + info.subSample.push_back(testSubsample); + testSubsample.clearHeaderLen = 1024; // 1024 = 1kb + testSubsample.payLoadLen = 507 * 1024; // 1024 = 1kb 507kb + info.subSample.push_back(testSubsample); + testSubsample.clearHeaderLen = 24; // 24 = 16 + 8 + testSubsample.payLoadLen = 2 * 1024 * 1024; // 1024 = 1kb 2M + info.subSample.push_back(testSubsample); + testSubsample.clearHeaderLen = 1024; // 1024 = 1kb + testSubsample.payLoadLen = 0; + info.subSample.push_back(testSubsample); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_Dump_01, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + + if (mediaKeySession) { + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); + sptr SessionServiceProxy = + sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy(); + sptr decryptModule; + SessionServiceProxy->GetMediaDecryptModule(decryptModule); + MessageParcel data; + DrmBuffer srcBuffer; + DrmBuffer dstBuffer; + bool secureDecodrtState = false; + CryptInfo cryptInfo; + decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); + decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); + decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); + PrepareCryptoInfo_HugeSubsample(cryptInfo); + decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); + system("hidumper -s 3012"); + decryptModule->Release(); + } + + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystem_MAX_01, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + const uint32_t maxNum = 64; + std::vector systems(maxNum, nullptr); + const char *name = GetUuid(); + for (uint i = 0; i < maxNum; i++) { + errNo = OH_MediaKeySystem_Create(name, &systems[i]); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_NE(systems[i], nullptr); + } + + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(name, &mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_MAX_SYSTEM_NUM_REACHED); + EXPECT_EQ(mediaKeySystem, nullptr); + + for (uint i = 0; i < maxNum; i++) { + errNo = OH_MediaKeySystem_Destroy(systems[i]); + systems[i] = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); + } +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySession_MAX_01, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + const uint32_t maxNum = 64; + std::vector sessions(maxNum, nullptr); + + MediaKeySystem *mediaKeySystem = nullptr; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + for (uint i = 0; i < maxNum; i++) { + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &sessions[i]); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_NE(sessions[i], nullptr); + } + + MediaKeySession *mediaKeySession = nullptr; + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_MAX_SESSION_NUM_REACHED); + EXPECT_EQ(mediaKeySession, nullptr); + + for (uint i = 0; i < maxNum; i++) { + errNo = OH_MediaKeySession_Destroy(sessions[i]); + sessions[i] = nullptr; + EXPECT_EQ(errNo, DRM_ERR_OK); + } + + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_IsUuidValid_01, TestSize.Level0) +{ + EXPECT_TRUE(IsUuidValid("0123456789ABCDEF")); + EXPECT_TRUE(IsUuidValid("abcdef1234567890")); + EXPECT_TRUE(IsUuidValid("a1b2c3d4e5f6")); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_IsUuidValid_02, TestSize.Level0) +{ + EXPECT_FALSE(IsUuidValid("")); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_IsUuidValid_03, TestSize.Level0) +{ + EXPECT_FALSE(IsUuidValid("123G456")); + EXPECT_FALSE(IsUuidValid("xyz123")); + EXPECT_FALSE(IsUuidValid("123456_")); + EXPECT_FALSE(IsUuidValid(" 123456")); +} + +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_IsUuidValid_04, TestSize.Level0) +{ + EXPECT_TRUE(IsUuidValid("0")); + EXPECT_TRUE(IsUuidValid("f")); + EXPECT_TRUE(IsUuidValid("F")); + EXPECT_TRUE(IsUuidValid("09AFaf")); + EXPECT_FALSE(IsUuidValid("09AG")); +} +} // DrmStandard +} // OHOS diff --git a/services/utils/include/drm_common_utils.h b/services/utils/include/drm_common_utils.h new file mode 100644 index 0000000..ab5558e --- /dev/null +++ b/services/utils/include/drm_common_utils.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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_COMMON_UTILS_H +#define DRM_COMMON_UTILS_H +#include +#include +#include "drm_log.h" + +namespace OHOS { +namespace DrmStandard { +inline bool IsUuidValid(const std::string &uuid) +{ + DRM_CHECK_AND_RETURN_RET_LOG(!uuid.empty(), false, "uuid is empty"); + for (uint32_t i = 0; i < uuid.size(); i++) { + DRM_CHECK_AND_RETURN_RET_LOG(isxdigit(uuid[i]), false, "uuid is invalid"); + } + return true; +} + +} // namespace DrmStandard +} // namespace OHOS + +#endif \ No newline at end of file -- Gitee From ebeb4823c801aab4f8f6b9e5ad153105ab1e6060 Mon Sep 17 00:00:00 2001 From: zpf Date: Wed, 3 Sep 2025 20:31:05 +0800 Subject: [PATCH 2/2] delete space Signed-off-by: zpf --- .../test/unittest/src/drm_framework_unittest.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp index 03e0464..fe9c2bb 100644 --- a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp +++ b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp @@ -3969,11 +3969,11 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_IsUuidValid_03, TestSize.Level0) HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_IsUuidValid_04, TestSize.Level0) { - EXPECT_TRUE(IsUuidValid("0")); - EXPECT_TRUE(IsUuidValid("f")); - EXPECT_TRUE(IsUuidValid("F")); - EXPECT_TRUE(IsUuidValid("09AFaf")); - EXPECT_FALSE(IsUuidValid("09AG")); + EXPECT_TRUE(IsUuidValid("0")); + EXPECT_TRUE(IsUuidValid("f")); + EXPECT_TRUE(IsUuidValid("F")); + EXPECT_TRUE(IsUuidValid("09AFaf")); + EXPECT_FALSE(IsUuidValid("09AG")); } } // DrmStandard } // OHOS -- Gitee