| /* |
| * 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/BnTranscodingClientCallback.h> |
| #include <aidl/android/media/IMediaTranscodingService.h> |
| #include <android-base/logging.h> |
| #include <android/binder_manager.h> |
| #include <android/binder_process.h> |
| #include <gtest/gtest.h> |
| #include <media/ControllerClientInterface.h> |
| #include <media/TranscodingClientManager.h> |
| #include <media/TranscodingRequest.h> |
| #include <utils/Log.h> |
| |
| #include <list> |
| |
| namespace android { |
| |
| using Status = ::ndk::ScopedAStatus; |
| using ::aidl::android::media::BnTranscodingClientCallback; |
| using ::aidl::android::media::IMediaTranscodingService; |
| using ::aidl::android::media::TranscodingErrorCode; |
| using ::aidl::android::media::TranscodingRequestParcel; |
| using ::aidl::android::media::TranscodingResultParcel; |
| using ::aidl::android::media::TranscodingSessionParcel; |
| using ::aidl::android::media::TranscodingSessionPriority; |
| |
| constexpr pid_t kInvalidClientPid = -5; |
| constexpr pid_t kInvalidClientUid = -10; |
| constexpr const char* kInvalidClientName = ""; |
| constexpr const char* kInvalidClientPackage = ""; |
| |
| constexpr const char* kClientName = "TestClientName"; |
| constexpr const char* kClientPackage = "TestClientPackage"; |
| constexpr uid_t OFFLINE_UID = -1; |
| |
| #define SESSION(n) (n) |
| |
| struct TestClientCallback : public BnTranscodingClientCallback { |
| TestClientCallback() { ALOGI("TestClientCallback Created"); } |
| |
| virtual ~TestClientCallback() { ALOGI("TestClientCallback destroyed"); }; |
| |
| Status openFileDescriptor(const std::string& /*in_fileUri*/, const std::string& /*in_mode*/, |
| ::ndk::ScopedFileDescriptor* /*_aidl_return*/) override { |
| return Status::ok(); |
| } |
| |
| Status onTranscodingStarted(int32_t /*in_sessionId*/) override { return Status::ok(); } |
| |
| Status onTranscodingPaused(int32_t /*in_sessionId*/) override { return Status::ok(); } |
| |
| Status onTranscodingResumed(int32_t /*in_sessionId*/) override { return Status::ok(); } |
| |
| Status onTranscodingFinished(int32_t in_sessionId, |
| const TranscodingResultParcel& in_result) override { |
| EXPECT_EQ(in_sessionId, in_result.sessionId); |
| mEventQueue.push_back(Finished(in_sessionId)); |
| return Status::ok(); |
| } |
| |
| Status onTranscodingFailed(int32_t in_sessionId, |
| TranscodingErrorCode /*in_errorCode */) override { |
| mEventQueue.push_back(Failed(in_sessionId)); |
| return Status::ok(); |
| } |
| |
| Status onAwaitNumberOfSessionsChanged(int32_t /* in_sessionId */, |
| int32_t /* in_oldAwaitNumber */, |
| int32_t /* in_newAwaitNumber */) override { |
| return Status::ok(); |
| } |
| |
| Status onProgressUpdate(int32_t /* in_sessionId */, int32_t /* in_progress */) override { |
| return Status::ok(); |
| } |
| |
| struct Event { |
| enum { |
| NoEvent, |
| Finished, |
| Failed, |
| } type; |
| SessionIdType sessionId; |
| }; |
| |
| static constexpr Event NoEvent = {Event::NoEvent, 0}; |
| #define DECLARE_EVENT(action) \ |
| static Event action(SessionIdType sessionId) { return {Event::action, sessionId}; } |
| |
| DECLARE_EVENT(Finished); |
| DECLARE_EVENT(Failed); |
| |
| const Event& popEvent() { |
| if (mEventQueue.empty()) { |
| mPoppedEvent = NoEvent; |
| } else { |
| mPoppedEvent = *mEventQueue.begin(); |
| mEventQueue.pop_front(); |
| } |
| return mPoppedEvent; |
| } |
| |
| private: |
| Event mPoppedEvent; |
| std::list<Event> mEventQueue; |
| |
| TestClientCallback(const TestClientCallback&) = delete; |
| TestClientCallback& operator=(const TestClientCallback&) = delete; |
| }; |
| |
| bool operator==(const TestClientCallback::Event& lhs, const TestClientCallback::Event& rhs) { |
| return lhs.type == rhs.type && lhs.sessionId == rhs.sessionId; |
| } |
| |
| struct TestController : public ControllerClientInterface { |
| TestController() { ALOGI("TestController Created"); } |
| |
| virtual ~TestController() { ALOGI("TestController Destroyed"); } |
| |
| bool submit(ClientIdType clientId, SessionIdType sessionId, uid_t /*callingUid*/, |
| uid_t clientUid, const TranscodingRequestParcel& request, |
| const std::weak_ptr<ITranscodingClientCallback>& clientCallback) override { |
| SessionKeyType sessionKey = std::make_pair(clientId, sessionId); |
| if (mSessions.count(sessionKey) > 0) { |
| return false; |
| } |
| |
| // This is the secret name we'll check, to test error propagation from |
| // the controller back to client. |
| if (request.sourceFilePath == "bad_source_file") { |
| return false; |
| } |
| |
| if (request.priority == TranscodingSessionPriority::kUnspecified) { |
| clientUid = OFFLINE_UID; |
| } |
| |
| mSessions[sessionKey].request = request; |
| mSessions[sessionKey].callback = clientCallback; |
| mSessions[sessionKey].allClientUids.insert(clientUid); |
| |
| mLastSession = sessionKey; |
| return true; |
| } |
| |
| bool addClientUid(ClientIdType clientId, SessionIdType sessionId, uid_t clientUid) override { |
| SessionKeyType sessionKey = std::make_pair(clientId, sessionId); |
| |
| if (mSessions.count(sessionKey) == 0) { |
| return false; |
| } |
| if (mSessions[sessionKey].allClientUids.count(clientUid) > 0) { |
| return false; |
| } |
| mSessions[sessionKey].allClientUids.insert(clientUid); |
| return true; |
| } |
| |
| bool getClientUids(ClientIdType clientId, SessionIdType sessionId, |
| std::vector<int32_t>* out_clientUids) override { |
| SessionKeyType sessionKey = std::make_pair(clientId, sessionId); |
| |
| if (mSessions.count(sessionKey) == 0) { |
| return false; |
| } |
| out_clientUids->clear(); |
| for (uid_t uid : mSessions[sessionKey].allClientUids) { |
| if (uid != OFFLINE_UID) { |
| out_clientUids->push_back(uid); |
| } |
| } |
| return true; |
| } |
| |
| bool cancel(ClientIdType clientId, SessionIdType sessionId) override { |
| SessionKeyType sessionKey = std::make_pair(clientId, sessionId); |
| |
| if (mSessions.count(sessionKey) == 0) { |
| return false; |
| } |
| mSessions.erase(sessionKey); |
| return true; |
| } |
| |
| bool getSession(ClientIdType clientId, SessionIdType sessionId, |
| TranscodingRequestParcel* request) override { |
| SessionKeyType sessionKey = std::make_pair(clientId, sessionId); |
| if (mSessions.count(sessionKey) == 0) { |
| return false; |
| } |
| |
| *(TranscodingRequest*)request = mSessions[sessionKey].request; |
| return true; |
| } |
| |
| void finishLastSession() { |
| auto it = mSessions.find(mLastSession); |
| if (it == mSessions.end()) { |
| return; |
| } |
| { |
| auto clientCallback = it->second.callback.lock(); |
| if (clientCallback != nullptr) { |
| clientCallback->onTranscodingFinished( |
| mLastSession.second, |
| TranscodingResultParcel({mLastSession.second, 0, std::nullopt})); |
| } |
| } |
| mSessions.erase(it); |
| } |
| |
| void abortLastSession() { |
| auto it = mSessions.find(mLastSession); |
| if (it == mSessions.end()) { |
| return; |
| } |
| { |
| auto clientCallback = it->second.callback.lock(); |
| if (clientCallback != nullptr) { |
| clientCallback->onTranscodingFailed(mLastSession.second, |
| TranscodingErrorCode::kUnknown); |
| } |
| } |
| mSessions.erase(it); |
| } |
| |
| struct Session { |
| TranscodingRequest request; |
| std::weak_ptr<ITranscodingClientCallback> callback; |
| std::unordered_set<uid_t> allClientUids; |
| }; |
| |
| typedef std::pair<ClientIdType, SessionIdType> SessionKeyType; |
| std::map<SessionKeyType, Session> mSessions; |
| SessionKeyType mLastSession; |
| }; |
| |
| class TranscodingClientManagerTest : public ::testing::Test { |
| public: |
| TranscodingClientManagerTest() |
| : mController(new TestController()), |
| mClientManager(new TranscodingClientManager(mController)) { |
| ALOGD("TranscodingClientManagerTest created"); |
| } |
| |
| void SetUp() override { |
| mClientCallback1 = ::ndk::SharedRefBase::make<TestClientCallback>(); |
| mClientCallback2 = ::ndk::SharedRefBase::make<TestClientCallback>(); |
| mClientCallback3 = ::ndk::SharedRefBase::make<TestClientCallback>(); |
| } |
| |
| void TearDown() override { ALOGI("TranscodingClientManagerTest tear down"); } |
| |
| ~TranscodingClientManagerTest() { ALOGD("TranscodingClientManagerTest destroyed"); } |
| |
| void addMultipleClients() { |
| EXPECT_EQ( |
| mClientManager->addClient(mClientCallback1, kClientName, kClientPackage, &mClient1), |
| OK); |
| EXPECT_NE(mClient1, nullptr); |
| |
| EXPECT_EQ( |
| mClientManager->addClient(mClientCallback2, kClientName, kClientPackage, &mClient2), |
| OK); |
| EXPECT_NE(mClient2, nullptr); |
| |
| EXPECT_EQ( |
| mClientManager->addClient(mClientCallback3, kClientName, kClientPackage, &mClient3), |
| OK); |
| EXPECT_NE(mClient3, nullptr); |
| |
| EXPECT_EQ(mClientManager->getNumOfClients(), 3); |
| } |
| |
| void unregisterMultipleClients() { |
| EXPECT_TRUE(mClient1->unregister().isOk()); |
| EXPECT_TRUE(mClient2->unregister().isOk()); |
| EXPECT_TRUE(mClient3->unregister().isOk()); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 0); |
| } |
| |
| std::shared_ptr<TestController> mController; |
| std::shared_ptr<TranscodingClientManager> mClientManager; |
| std::shared_ptr<ITranscodingClient> mClient1; |
| std::shared_ptr<ITranscodingClient> mClient2; |
| std::shared_ptr<ITranscodingClient> mClient3; |
| std::shared_ptr<TestClientCallback> mClientCallback1; |
| std::shared_ptr<TestClientCallback> mClientCallback2; |
| std::shared_ptr<TestClientCallback> mClientCallback3; |
| }; |
| |
| TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientCallback) { |
| // Add a client with null callback and expect failure. |
| std::shared_ptr<ITranscodingClient> client; |
| status_t err = mClientManager->addClient(nullptr, kClientName, kClientPackage, &client); |
| EXPECT_EQ(err, IMediaTranscodingService::ERROR_ILLEGAL_ARGUMENT); |
| } |
| // |
| //TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientPid) { |
| // // Add a client with invalid Pid and expect failure. |
| // std::shared_ptr<ITranscodingClient> client; |
| // status_t err = mClientManager->addClient(mClientCallback1, |
| // kClientName, kClientPackage, &client); |
| // EXPECT_EQ(err, IMediaTranscodingService::ERROR_ILLEGAL_ARGUMENT); |
| //} |
| |
| TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientName) { |
| // Add a client with invalid name and expect failure. |
| std::shared_ptr<ITranscodingClient> client; |
| status_t err = mClientManager->addClient(mClientCallback1, kInvalidClientName, kClientPackage, |
| &client); |
| EXPECT_EQ(err, IMediaTranscodingService::ERROR_ILLEGAL_ARGUMENT); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestAddingWithInvalidClientPackageName) { |
| // Add a client with invalid packagename and expect failure. |
| std::shared_ptr<ITranscodingClient> client; |
| status_t err = mClientManager->addClient(mClientCallback1, kClientName, kInvalidClientPackage, |
| &client); |
| EXPECT_EQ(err, IMediaTranscodingService::ERROR_ILLEGAL_ARGUMENT); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestAddingValidClient) { |
| // Add a valid client, should succeed. |
| std::shared_ptr<ITranscodingClient> client; |
| status_t err = |
| mClientManager->addClient(mClientCallback1, kClientName, kClientPackage, &client); |
| EXPECT_EQ(err, OK); |
| EXPECT_NE(client.get(), nullptr); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 1); |
| |
| // Unregister client, should succeed. |
| Status status = client->unregister(); |
| EXPECT_TRUE(status.isOk()); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 0); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestAddingDupliacteClient) { |
| std::shared_ptr<ITranscodingClient> client; |
| status_t err = |
| mClientManager->addClient(mClientCallback1, kClientName, kClientPackage, &client); |
| EXPECT_EQ(err, OK); |
| EXPECT_NE(client.get(), nullptr); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 1); |
| |
| std::shared_ptr<ITranscodingClient> dupClient; |
| err = mClientManager->addClient(mClientCallback1, "dupClient", "dupPackage", &dupClient); |
| EXPECT_EQ(err, IMediaTranscodingService::ERROR_ALREADY_EXISTS); |
| EXPECT_EQ(dupClient.get(), nullptr); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 1); |
| |
| Status status = client->unregister(); |
| EXPECT_TRUE(status.isOk()); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 0); |
| |
| err = mClientManager->addClient(mClientCallback1, "dupClient", "dupPackage", &dupClient); |
| EXPECT_EQ(err, OK); |
| EXPECT_NE(dupClient.get(), nullptr); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 1); |
| |
| status = dupClient->unregister(); |
| EXPECT_TRUE(status.isOk()); |
| EXPECT_EQ(mClientManager->getNumOfClients(), 0); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestAddingMultipleClient) { |
| addMultipleClients(); |
| unregisterMultipleClients(); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestSubmitCancelGetSessions) { |
| addMultipleClients(); |
| |
| // Test sessionId assignment. |
| TranscodingRequestParcel request; |
| request.sourceFilePath = "test_source_file_0"; |
| request.destinationFilePath = "test_desintaion_file_0"; |
| TranscodingSessionParcel session; |
| bool result; |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(0)); |
| |
| request.sourceFilePath = "test_source_file_1"; |
| request.destinationFilePath = "test_desintaion_file_1"; |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(1)); |
| |
| request.sourceFilePath = "test_source_file_2"; |
| request.destinationFilePath = "test_desintaion_file_2"; |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(2)); |
| |
| // Test submit bad request (no valid sourceFilePath) fails. |
| TranscodingRequestParcel badRequest; |
| badRequest.sourceFilePath = "bad_source_file"; |
| badRequest.destinationFilePath = "bad_destination_file"; |
| EXPECT_TRUE(mClient1->submitRequest(badRequest, &session, &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Test submit with bad pid/uid. |
| badRequest.sourceFilePath = "test_source_file_3"; |
| badRequest.destinationFilePath = "test_desintaion_file_3"; |
| badRequest.clientPid = kInvalidClientPid; |
| badRequest.clientUid = kInvalidClientUid; |
| EXPECT_TRUE(mClient1->submitRequest(badRequest, &session, &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Test get sessions by id. |
| EXPECT_TRUE(mClient1->getSessionWithId(SESSION(2), &session, &result).isOk()); |
| EXPECT_EQ(session.sessionId, SESSION(2)); |
| EXPECT_EQ(session.request.sourceFilePath, "test_source_file_2"); |
| EXPECT_TRUE(result); |
| |
| // Test get sessions by invalid id fails. |
| EXPECT_TRUE(mClient1->getSessionWithId(SESSION(100), &session, &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Test cancel non-existent session fail. |
| EXPECT_TRUE(mClient2->cancelSession(SESSION(100), &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Test cancel valid sessionId in arbitrary order. |
| EXPECT_TRUE(mClient1->cancelSession(SESSION(2), &result).isOk()); |
| EXPECT_TRUE(result); |
| |
| EXPECT_TRUE(mClient1->cancelSession(SESSION(0), &result).isOk()); |
| EXPECT_TRUE(result); |
| |
| EXPECT_TRUE(mClient1->cancelSession(SESSION(1), &result).isOk()); |
| EXPECT_TRUE(result); |
| |
| // Test cancel session again fails. |
| EXPECT_TRUE(mClient1->cancelSession(SESSION(1), &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Test get session after cancel fails. |
| EXPECT_TRUE(mClient1->getSessionWithId(SESSION(2), &session, &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Test sessionId independence for each client. |
| EXPECT_TRUE(mClient2->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(0)); |
| |
| EXPECT_TRUE(mClient2->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(1)); |
| |
| unregisterMultipleClients(); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestClientCallback) { |
| addMultipleClients(); |
| |
| TranscodingRequestParcel request; |
| request.sourceFilePath = "test_source_file_name"; |
| request.destinationFilePath = "test_destination_file_name"; |
| TranscodingSessionParcel session; |
| bool result; |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(0)); |
| |
| mController->finishLastSession(); |
| EXPECT_EQ(mClientCallback1->popEvent(), TestClientCallback::Finished(session.sessionId)); |
| |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(1)); |
| |
| mController->abortLastSession(); |
| EXPECT_EQ(mClientCallback1->popEvent(), TestClientCallback::Failed(session.sessionId)); |
| |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(2)); |
| |
| EXPECT_TRUE(mClient2->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_EQ(session.sessionId, SESSION(0)); |
| |
| mController->finishLastSession(); |
| EXPECT_EQ(mClientCallback2->popEvent(), TestClientCallback::Finished(session.sessionId)); |
| |
| unregisterMultipleClients(); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestUseAfterUnregister) { |
| // Add a client. |
| std::shared_ptr<ITranscodingClient> client; |
| status_t err = |
| mClientManager->addClient(mClientCallback1, kClientName, kClientPackage, &client); |
| EXPECT_EQ(err, OK); |
| EXPECT_NE(client.get(), nullptr); |
| |
| // Submit 2 requests, 1 offline and 1 realtime. |
| TranscodingRequestParcel request; |
| TranscodingSessionParcel session; |
| bool result; |
| |
| request.sourceFilePath = "test_source_file_0"; |
| request.destinationFilePath = "test_destination_file_0"; |
| request.priority = TranscodingSessionPriority::kUnspecified; |
| EXPECT_TRUE(client->submitRequest(request, &session, &result).isOk() && result); |
| EXPECT_EQ(session.sessionId, SESSION(0)); |
| |
| request.sourceFilePath = "test_source_file_1"; |
| request.destinationFilePath = "test_destination_file_1"; |
| request.priority = TranscodingSessionPriority::kNormal; |
| EXPECT_TRUE(client->submitRequest(request, &session, &result).isOk() && result); |
| EXPECT_EQ(session.sessionId, SESSION(1)); |
| |
| // Unregister client, should succeed. |
| Status status = client->unregister(); |
| EXPECT_TRUE(status.isOk()); |
| |
| // Test submit new request after unregister, should fail with ERROR_DISCONNECTED. |
| request.sourceFilePath = "test_source_file_2"; |
| request.destinationFilePath = "test_destination_file_2"; |
| request.priority = TranscodingSessionPriority::kNormal; |
| status = client->submitRequest(request, &session, &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED); |
| |
| // Test cancel sessions after unregister, should fail with ERROR_DISCONNECTED |
| // regardless of realtime or offline session, or whether the sessionId is valid. |
| status = client->cancelSession(SESSION(0), &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED); |
| |
| status = client->cancelSession(SESSION(1), &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED); |
| |
| status = client->cancelSession(SESSION(2), &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED); |
| |
| // Test get sessions, should fail with ERROR_DISCONNECTED regardless of realtime |
| // or offline session, or whether the sessionId is valid. |
| status = client->getSessionWithId(SESSION(0), &session, &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED); |
| |
| status = client->getSessionWithId(SESSION(1), &session, &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED); |
| |
| status = client->getSessionWithId(SESSION(2), &session, &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestAddGetClientUidsInvalidArgs) { |
| addMultipleClients(); |
| |
| bool result; |
| std::optional<std::vector<int32_t>> clientUids; |
| TranscodingRequestParcel request; |
| TranscodingSessionParcel session; |
| uid_t ownUid = ::getuid(); |
| |
| // Add/Get clients with invalid session id fails. |
| EXPECT_TRUE(mClient1->addClientUid(-1, ownUid, &result).isOk()); |
| EXPECT_FALSE(result); |
| EXPECT_TRUE(mClient1->addClientUid(SESSION(0), ownUid, &result).isOk()); |
| EXPECT_FALSE(result); |
| EXPECT_TRUE(mClient1->getClientUids(-1, &clientUids).isOk()); |
| EXPECT_EQ(clientUids, std::nullopt); |
| EXPECT_TRUE(mClient1->getClientUids(SESSION(0), &clientUids).isOk()); |
| EXPECT_EQ(clientUids, std::nullopt); |
| |
| unregisterMultipleClients(); |
| } |
| |
| TEST_F(TranscodingClientManagerTest, TestAddGetClientUids) { |
| addMultipleClients(); |
| |
| bool result; |
| std::optional<std::vector<int32_t>> clientUids; |
| TranscodingRequestParcel request; |
| TranscodingSessionParcel session; |
| uid_t ownUid = ::getuid(); |
| |
| // Submit one real-time session. |
| request.sourceFilePath = "test_source_file_0"; |
| request.destinationFilePath = "test_desintaion_file_0"; |
| request.priority = TranscodingSessionPriority::kNormal; |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| |
| // Should have own uid in client uid list. |
| EXPECT_TRUE(mClient1->getClientUids(SESSION(0), &clientUids).isOk()); |
| EXPECT_NE(clientUids, std::nullopt); |
| EXPECT_EQ(clientUids->size(), 1); |
| EXPECT_EQ((*clientUids)[0], ownUid); |
| |
| // Adding invalid client uid should fail. |
| EXPECT_TRUE(mClient1->addClientUid(SESSION(0), kInvalidClientUid, &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Adding own uid again should fail. |
| EXPECT_TRUE(mClient1->addClientUid(SESSION(0), ownUid, &result).isOk()); |
| EXPECT_FALSE(result); |
| |
| // Submit one offline session. |
| request.sourceFilePath = "test_source_file_1"; |
| request.destinationFilePath = "test_desintaion_file_1"; |
| request.priority = TranscodingSessionPriority::kUnspecified; |
| EXPECT_TRUE(mClient1->submitRequest(request, &session, &result).isOk()); |
| EXPECT_TRUE(result); |
| |
| // Should not have own uid in client uid list. |
| EXPECT_TRUE(mClient1->getClientUids(SESSION(1), &clientUids).isOk()); |
| EXPECT_NE(clientUids, std::nullopt); |
| EXPECT_EQ(clientUids->size(), 0); |
| |
| // Add own uid (with IMediaTranscodingService::USE_CALLING_UID) again, should succeed. |
| EXPECT_TRUE( |
| mClient1->addClientUid(SESSION(1), IMediaTranscodingService::USE_CALLING_UID, &result) |
| .isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_TRUE(mClient1->getClientUids(SESSION(1), &clientUids).isOk()); |
| EXPECT_NE(clientUids, std::nullopt); |
| EXPECT_EQ(clientUids->size(), 1); |
| EXPECT_EQ((*clientUids)[0], ownUid); |
| |
| // Add more uids, should succeed. |
| int32_t kFakeUid = ::getuid() ^ 0x1; |
| EXPECT_TRUE(mClient1->addClientUid(SESSION(1), kFakeUid, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_TRUE(mClient1->getClientUids(SESSION(1), &clientUids).isOk()); |
| EXPECT_NE(clientUids, std::nullopt); |
| std::unordered_set<uid_t> uidSet; |
| uidSet.insert(clientUids->begin(), clientUids->end()); |
| EXPECT_EQ(uidSet.size(), 2); |
| EXPECT_EQ(uidSet.count(ownUid), 1); |
| EXPECT_EQ(uidSet.count(kFakeUid), 1); |
| |
| unregisterMultipleClients(); |
| } |
| |
| } // namespace android |
