media/libmediatranscoding/tests/TranscodingClientManager_tests.cpp - android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 // Unit Test for TranscodingClientManager

 // #define LOG_NDEBUG 0
 #define LOG_TAG "TranscodingClientManagerTest"

 #include <aidl/android/media/BnTranscodingServiceClient.h>
 #include <aidl/android/media/IMediaTranscodingService.h>
 #include <aidl/android/media/ITranscodingServiceClient.h>
 #include <android-base/logging.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
 #include <gtest/gtest.h>
 #include <media/TranscodingClientManager.h>
 #include <utils/Log.h>

 namespace android {

 using Status = ::ndk::ScopedAStatus;
 using aidl::android::media::BnTranscodingServiceClient;
 using aidl::android::media::IMediaTranscodingService;
 using aidl::android::media::ITranscodingServiceClient;

 constexpr int32_t kInvalidClientId = -1;
 constexpr int32_t kInvalidClientPid = -1;
 constexpr int32_t kInvalidClientUid = -1;
 constexpr const char* kInvalidClientOpPackageName = "";

 constexpr int32_t kClientId = 1;
 constexpr int32_t kClientPid = 2;
 constexpr int32_t kClientUid = 3;
 constexpr const char* kClientOpPackageName = "TestClient";

 struct TestClient : public BnTranscodingServiceClient {
     TestClient(const std::shared_ptr<IMediaTranscodingService>& service) : mService(service) {
         ALOGD("TestClient Created");
     }

     Status getName(std::string* _aidl_return) override {
         *_aidl_return = "test_client";
         return Status::ok();
     }

     Status onTranscodingFinished(
             int32_t /* in_jobId */,
             const ::aidl::android::media::TranscodingResultParcel& /* in_result */) override {
         return Status::ok();
     }

     Status onTranscodingFailed(
             int32_t /* in_jobId */,
             ::aidl::android::media::TranscodingErrorCode /*in_errorCode */) override {
         return Status::ok();
     }

     Status onAwaitNumberOfJobsChanged(int32_t /* in_jobId */, int32_t /* in_oldAwaitNumber */,
                                       int32_t /* in_newAwaitNumber */) override {
         return Status::ok();
     }

     Status onProgressUpdate(int32_t /* in_jobId */, int32_t /* in_progress */) override {
         return Status::ok();
     }

     virtual ~TestClient() { ALOGI("TestClient destroyed"); };

    private:
     std::shared_ptr<IMediaTranscodingService> mService;
     TestClient(const TestClient&) = delete;
     TestClient& operator=(const TestClient&) = delete;
 };

 class TranscodingClientManagerTest : public ::testing::Test {
    public:
     TranscodingClientManagerTest() { ALOGD("TranscodingClientManagerTest created"); }

     void SetUp() override {
         mClientManager = TranscodingClientManager::getInstance();
         if (mClientManager == nullptr) {
             ALOGE("Failed to acquire TranscodingClientManager.");
             return;
         }

         ::ndk::SpAIBinder binder(AServiceManager_getService("media.transcoding"));
         mService = IMediaTranscodingService::fromBinder(binder);
         if (mService == nullptr) {
             ALOGE("Failed to connect to the media.trascoding service.");
             return;
         }

         mTestClient = ::ndk::SharedRefBase::make<TestClient>(mService);
     }

     void TearDown() override {
         ALOGI("TranscodingClientManagerTest tear down");
         mClientManager = nullptr;
         mService = nullptr;
     }

     ~TranscodingClientManagerTest() { ALOGD("TranscodingClientManagerTest destroyed"); }

     sp<TranscodingClientManager> mClientManager = nullptr;
     std::shared_ptr<ITranscodingServiceClient> mTestClient = nullptr;
     std::shared_ptr<IMediaTranscodingService> mService = nullptr;
 };

 TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientId) {
     std::shared_ptr<ITranscodingServiceClient> client =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     // Create a client with invalid client id.
     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client, kInvalidClientId, kClientPid, kClientUid, kClientOpPackageName);

     // Add the client to the manager and expect failure.
     status_t err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err != OK);
 }

 TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientPid) {
     std::shared_ptr<ITranscodingServiceClient> client =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     // Create a client with invalid Pid.
     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client, kClientId, kInvalidClientPid, kClientUid, kClientOpPackageName);

     // Add the client to the manager and expect failure.
     status_t err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err != OK);
 }

 TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientUid) {
     std::shared_ptr<ITranscodingServiceClient> client =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     // Create a client with invalid Uid.
     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client, kClientId, kClientPid, kInvalidClientUid, kClientOpPackageName);

     // Add the client to the manager and expect failure.
     status_t err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err != OK);
 }

 TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientPackageName) {
     std::shared_ptr<ITranscodingServiceClient> client =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     // Create a client with invalid packagename.
     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client, kClientId, kClientPid, kClientUid, kInvalidClientOpPackageName);

     // Add the client to the manager and expect failure.
     status_t err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err != OK);
 }

 TEST_F(TranscodingClientManagerTest, TestAddingValidClient) {
     std::shared_ptr<ITranscodingServiceClient> client1 =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client1, kClientId, kClientPid, kClientUid, kClientOpPackageName);

     status_t err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err == OK);

     size_t numOfClients = mClientManager->getNumOfClients();
     EXPECT_EQ(numOfClients, 1);

     err = mClientManager->removeClient(kClientId);
     EXPECT_TRUE(err == OK);
 }

 TEST_F(TranscodingClientManagerTest, TestAddingDupliacteClient) {
     std::shared_ptr<ITranscodingServiceClient> client1 =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client1, kClientId, kClientPid, kClientUid, kClientOpPackageName);

     status_t err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err == OK);

     err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err != OK);

     err = mClientManager->removeClient(kClientId);
     EXPECT_TRUE(err == OK);
 }

 TEST_F(TranscodingClientManagerTest, TestAddingMultipleClient) {
     std::shared_ptr<ITranscodingServiceClient> client1 =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo1 =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client1, kClientId, kClientPid, kClientUid, kClientOpPackageName);

     status_t err = mClientManager->addClient(std::move(clientInfo1));
     EXPECT_TRUE(err == OK);

     std::shared_ptr<ITranscodingServiceClient> client2 =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo2 =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client2, kClientId + 1, kClientPid, kClientUid, kClientOpPackageName);

     err = mClientManager->addClient(std::move(clientInfo2));
     EXPECT_TRUE(err == OK);

     std::shared_ptr<ITranscodingServiceClient> client3 =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     // Create a client with invalid packagename.
     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo3 =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client3, kClientId + 2, kClientPid, kClientUid, kClientOpPackageName);

     err = mClientManager->addClient(std::move(clientInfo3));
     EXPECT_TRUE(err == OK);

     size_t numOfClients = mClientManager->getNumOfClients();
     EXPECT_EQ(numOfClients, 3);

     err = mClientManager->removeClient(kClientId);
     EXPECT_TRUE(err == OK);

     err = mClientManager->removeClient(kClientId + 1);
     EXPECT_TRUE(err == OK);

     err = mClientManager->removeClient(kClientId + 2);
     EXPECT_TRUE(err == OK);
 }

 TEST_F(TranscodingClientManagerTest, TestRemovingNonExistClient) {
     status_t err = mClientManager->removeClient(kInvalidClientId);
     EXPECT_TRUE(err != OK);

     err = mClientManager->removeClient(1000 /* clientId */);
     EXPECT_TRUE(err != OK);
 }

 TEST_F(TranscodingClientManagerTest, TestCheckClientWithClientId) {
     std::shared_ptr<ITranscodingServiceClient> client =
             ::ndk::SharedRefBase::make<TestClient>(mService);

     std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
             std::make_unique<TranscodingClientManager::ClientInfo>(
                     client, kClientId, kClientPid, kClientUid, kClientOpPackageName);

     status_t err = mClientManager->addClient(std::move(clientInfo));
     EXPECT_TRUE(err == OK);

     bool res = mClientManager->isClientIdRegistered(kClientId);
     EXPECT_TRUE(res);

     res = mClientManager->isClientIdRegistered(kInvalidClientId);
     EXPECT_FALSE(res);
 }

 }  // namespace android
	/*
	* Copyright (C) 2020 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	// Unit Test for TranscodingClientManager

	// #define LOG_NDEBUG 0
	#define LOG_TAG "TranscodingClientManagerTest"

	#include <aidl/android/media/BnTranscodingServiceClient.h>
	#include <aidl/android/media/IMediaTranscodingService.h>
	#include <aidl/android/media/ITranscodingServiceClient.h>
	#include <android-base/logging.h>
	#include <android/binder_manager.h>
	#include <android/binder_process.h>
	#include <gtest/gtest.h>
	#include <media/TranscodingClientManager.h>
	#include <utils/Log.h>

	namespace android {

	using Status = ::ndk::ScopedAStatus;
	using aidl::android::media::BnTranscodingServiceClient;
	using aidl::android::media::IMediaTranscodingService;
	using aidl::android::media::ITranscodingServiceClient;

	constexpr int32_t kInvalidClientId = -1;
	constexpr int32_t kInvalidClientPid = -1;
	constexpr int32_t kInvalidClientUid = -1;
	constexpr const char* kInvalidClientOpPackageName = "";

	constexpr int32_t kClientId = 1;
	constexpr int32_t kClientPid = 2;
	constexpr int32_t kClientUid = 3;
	constexpr const char* kClientOpPackageName = "TestClient";

	struct TestClient : public BnTranscodingServiceClient {
	TestClient(const std::shared_ptr<IMediaTranscodingService>& service) : mService(service) {
	ALOGD("TestClient Created");
	}

	Status getName(std::string* _aidl_return) override {
	*_aidl_return = "test_client";
	return Status::ok();
	}

	Status onTranscodingFinished(
	int32_t /* in_jobId */,
	const ::aidl::android::media::TranscodingResultParcel& /* in_result */) override {
	return Status::ok();
	}

	Status onTranscodingFailed(
	int32_t /* in_jobId */,
	::aidl::android::media::TranscodingErrorCode /in_errorCode /) override {
	return Status::ok();
	}

	Status onAwaitNumberOfJobsChanged(int32_t /* in_jobId /, int32_t / in_oldAwaitNumber */,
	int32_t /* in_newAwaitNumber */) override {
	return Status::ok();
	}

	Status onProgressUpdate(int32_t /* in_jobId /, int32_t / in_progress */) override {
	return Status::ok();
	}

	virtual ~TestClient() { ALOGI("TestClient destroyed"); };

	private:
	std::shared_ptr<IMediaTranscodingService> mService;
	TestClient(const TestClient&) = delete;
	TestClient& operator=(const TestClient&) = delete;
	};

	class TranscodingClientManagerTest : public ::testing::Test {
	public:
	TranscodingClientManagerTest() { ALOGD("TranscodingClientManagerTest created"); }

	void SetUp() override {
	mClientManager = TranscodingClientManager::getInstance();
	if (mClientManager == nullptr) {
	ALOGE("Failed to acquire TranscodingClientManager.");
	return;
	}

	::ndk::SpAIBinder binder(AServiceManager_getService("media.transcoding"));
	mService = IMediaTranscodingService::fromBinder(binder);
	if (mService == nullptr) {
	ALOGE("Failed to connect to the media.trascoding service.");
	return;
	}

	mTestClient = ::ndk::SharedRefBase::make<TestClient>(mService);
	}

	void TearDown() override {
	ALOGI("TranscodingClientManagerTest tear down");
	mClientManager = nullptr;
	mService = nullptr;
	}

	~TranscodingClientManagerTest() { ALOGD("TranscodingClientManagerTest destroyed"); }

	sp<TranscodingClientManager> mClientManager = nullptr;
	std::shared_ptr<ITranscodingServiceClient> mTestClient = nullptr;
	std::shared_ptr<IMediaTranscodingService> mService = nullptr;
	};

	TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientId) {
	std::shared_ptr<ITranscodingServiceClient> client =
	::ndk::SharedRefBase::make<TestClient>(mService);

	// Create a client with invalid client id.
	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client, kInvalidClientId, kClientPid, kClientUid, kClientOpPackageName);

	// Add the client to the manager and expect failure.
	status_t err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err != OK);
	}

	TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientPid) {
	std::shared_ptr<ITranscodingServiceClient> client =
	::ndk::SharedRefBase::make<TestClient>(mService);

	// Create a client with invalid Pid.
	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client, kClientId, kInvalidClientPid, kClientUid, kClientOpPackageName);

	// Add the client to the manager and expect failure.
	status_t err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err != OK);
	}

	TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientUid) {
	std::shared_ptr<ITranscodingServiceClient> client =
	::ndk::SharedRefBase::make<TestClient>(mService);

	// Create a client with invalid Uid.
	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client, kClientId, kClientPid, kInvalidClientUid, kClientOpPackageName);

	// Add the client to the manager and expect failure.
	status_t err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err != OK);
	}

	TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientPackageName) {
	std::shared_ptr<ITranscodingServiceClient> client =
	::ndk::SharedRefBase::make<TestClient>(mService);

	// Create a client with invalid packagename.
	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client, kClientId, kClientPid, kClientUid, kInvalidClientOpPackageName);

	// Add the client to the manager and expect failure.
	status_t err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err != OK);
	}

	TEST_F(TranscodingClientManagerTest, TestAddingValidClient) {
	std::shared_ptr<ITranscodingServiceClient> client1 =
	::ndk::SharedRefBase::make<TestClient>(mService);

	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client1, kClientId, kClientPid, kClientUid, kClientOpPackageName);

	status_t err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err == OK);

	size_t numOfClients = mClientManager->getNumOfClients();
	EXPECT_EQ(numOfClients, 1);

	err = mClientManager->removeClient(kClientId);
	EXPECT_TRUE(err == OK);
	}

	TEST_F(TranscodingClientManagerTest, TestAddingDupliacteClient) {
	std::shared_ptr<ITranscodingServiceClient> client1 =
	::ndk::SharedRefBase::make<TestClient>(mService);

	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client1, kClientId, kClientPid, kClientUid, kClientOpPackageName);

	status_t err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err == OK);

	err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err != OK);

	err = mClientManager->removeClient(kClientId);
	EXPECT_TRUE(err == OK);
	}

	TEST_F(TranscodingClientManagerTest, TestAddingMultipleClient) {
	std::shared_ptr<ITranscodingServiceClient> client1 =
	::ndk::SharedRefBase::make<TestClient>(mService);

	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo1 =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client1, kClientId, kClientPid, kClientUid, kClientOpPackageName);

	status_t err = mClientManager->addClient(std::move(clientInfo1));
	EXPECT_TRUE(err == OK);

	std::shared_ptr<ITranscodingServiceClient> client2 =
	::ndk::SharedRefBase::make<TestClient>(mService);

	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo2 =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client2, kClientId + 1, kClientPid, kClientUid, kClientOpPackageName);

	err = mClientManager->addClient(std::move(clientInfo2));
	EXPECT_TRUE(err == OK);

	std::shared_ptr<ITranscodingServiceClient> client3 =
	::ndk::SharedRefBase::make<TestClient>(mService);

	// Create a client with invalid packagename.
	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo3 =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client3, kClientId + 2, kClientPid, kClientUid, kClientOpPackageName);

	err = mClientManager->addClient(std::move(clientInfo3));
	EXPECT_TRUE(err == OK);

	size_t numOfClients = mClientManager->getNumOfClients();
	EXPECT_EQ(numOfClients, 3);

	err = mClientManager->removeClient(kClientId);
	EXPECT_TRUE(err == OK);

	err = mClientManager->removeClient(kClientId + 1);
	EXPECT_TRUE(err == OK);

	err = mClientManager->removeClient(kClientId + 2);
	EXPECT_TRUE(err == OK);
	}

	TEST_F(TranscodingClientManagerTest, TestRemovingNonExistClient) {
	status_t err = mClientManager->removeClient(kInvalidClientId);
	EXPECT_TRUE(err != OK);

	err = mClientManager->removeClient(1000 /* clientId */);
	EXPECT_TRUE(err != OK);
	}

	TEST_F(TranscodingClientManagerTest, TestCheckClientWithClientId) {
	std::shared_ptr<ITranscodingServiceClient> client =
	::ndk::SharedRefBase::make<TestClient>(mService);

	std::unique_ptr<TranscodingClientManager::ClientInfo> clientInfo =
	std::make_unique<TranscodingClientManager::ClientInfo>(
	client, kClientId, kClientPid, kClientUid, kClientOpPackageName);

	status_t err = mClientManager->addClient(std::move(clientInfo));
	EXPECT_TRUE(err == OK);

	bool res = mClientManager->isClientIdRegistered(kClientId);
	EXPECT_TRUE(res);

	res = mClientManager->isClientIdRegistered(kInvalidClientId);
	EXPECT_FALSE(res);
	}

	} // namespace android