services/mediatranscoding/tests/mediatranscodingservice_real_tests.cpp - LeafOS-Project/android_frameworks_av - Gitiles

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

 // Unit Test for MediaTranscodingService.

 //#define LOG_NDEBUG 0
 #define LOG_TAG "MediaTranscodingServiceRealTest"

 #include "MediaTranscodingServiceTestHelper.h"

 /*
  * Tests media transcoding service with real transcoder.
  *
  * Uses the same test assets as the MediaTranscoder unit tests. Before running the test,
  * please make sure to push the test assets to /sdcard:
  *
  * adb push $TOP/frameworks/av/media/libmediatranscoding/transcoder/tests/assets /data/local/tmp/TranscodingTestAssets
  */
 namespace android {

 namespace media {

 constexpr int64_t kPaddingUs = 1000000;
 constexpr int64_t kSessionWithPaddingUs = 10000000 + kPaddingUs;
 constexpr int32_t kBitRate = 8 * 1000 * 1000;  // 8Mbs

 constexpr const char* kShortSrcPath =
         "/data/local/tmp/TranscodingTestAssets/cubicle_avc_480x240_aac_24KHz.mp4";
 constexpr const char* kLongSrcPath = "/data/local/tmp/TranscodingTestAssets/longtest_15s.mp4";

 #define OUTPATH(name) "/data/local/tmp/MediaTranscodingService_" #name ".MP4"

 class MediaTranscodingServiceRealTest : public MediaTranscodingServiceTestBase {
 public:
     MediaTranscodingServiceRealTest() { ALOGI("MediaTranscodingServiceResourceTest created"); }

     virtual ~MediaTranscodingServiceRealTest() {
         ALOGI("MediaTranscodingServiceResourceTest destroyed");
     }
 };

 TEST_F(MediaTranscodingServiceRealTest, TestInvalidSource) {
     registerMultipleClients();

     const char* srcPath = "bad_file_uri";
     const char* dstPath = prepareOutputFile(OUTPATH(TestInvalidSource));

     // Submit one session.
     EXPECT_TRUE(
             mClient1->submit(0, srcPath, dstPath, TranscodingSessionPriority::kNormal, kBitRate));

     // Check expected error.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 0));
     EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kErrorIO);

     unregisterMultipleClients();
 }

 TEST_F(MediaTranscodingServiceRealTest, TestPassthru) {
     registerMultipleClients();

     const char* dstPath = prepareOutputFile(OUTPATH(TestPassthru));

     // Submit one session.
     EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath));

     // Wait for session to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

     unregisterMultipleClients();
 }

 TEST_F(MediaTranscodingServiceRealTest, TestTranscodeVideo) {
     registerMultipleClients();

     const char* dstPath = prepareOutputFile(OUTPATH(TestTranscodeVideo));

     // Submit one session.
     EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath, TranscodingSessionPriority::kNormal,
                                  kBitRate));

     // Wait for session to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

     unregisterMultipleClients();
 }

 TEST_F(MediaTranscodingServiceRealTest, TestTranscodeVideoProgress) {
     registerMultipleClients();

     const char* dstPath = prepareOutputFile(OUTPATH(TestTranscodeVideoProgress));

     // Submit one session.
     EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath, TranscodingSessionPriority::kNormal,
                                  kBitRate));

     // Wait for session to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

     // Check the progress update messages are received. For this clip (around ~15 second long),
     // expect at least 10 updates, and the last update should be 100.
     int lastProgress;
     EXPECT_GE(mClient1->getUpdateCount(&lastProgress), 10);
     EXPECT_EQ(lastProgress, 100);

     unregisterMultipleClients();
 }

 /*
  * Test cancel immediately after start.
  */
 TEST_F(MediaTranscodingServiceRealTest, TestCancelImmediately) {
     registerMultipleClients();

     const char* srcPath0 = kLongSrcPath;
     const char* srcPath1 = kShortSrcPath;
     const char* dstPath0 = prepareOutputFile(OUTPATH(TestCancelImmediately_Session0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestCancelImmediately_Session1));

     // Submit one session, should start immediately.
     EXPECT_TRUE(
             mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
     EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

     // Test cancel session immediately, getSession should fail after cancel.
     EXPECT_TRUE(mClient1->cancel(0));
     EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));

     // Submit new session, new session should start immediately and finish.
     EXPECT_TRUE(
             mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));

     unregisterMultipleClients();
 }

 /*
  * Test cancel in the middle of transcoding.
  */
 TEST_F(MediaTranscodingServiceRealTest, TestCancelWhileRunning) {
     registerMultipleClients();

     const char* srcPath0 = kLongSrcPath;
     const char* srcPath1 = kShortSrcPath;
     const char* dstPath0 = prepareOutputFile(OUTPATH(TestCancelWhileRunning_Session0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestCancelWhileRunning_Session1));

     // Submit two sessions, session 0 should start immediately, session 1 should be queued.
     EXPECT_TRUE(
             mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
     EXPECT_TRUE(
             mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
     EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
     EXPECT_TRUE(mClient1->getSession(1, srcPath1, dstPath1));

     // Session 0 (longtest) shouldn't finish in 1 seconds.
     EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);

     // Now cancel session 0. Session 1 should start immediately and finish.
     EXPECT_TRUE(mClient1->cancel(0));
     EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));

     unregisterMultipleClients();
 }

 TEST_F(MediaTranscodingServiceRealTest, TestPauseResumeSingleClient) {
     registerMultipleClients();

     const char* srcPath0 = kLongSrcPath;
     const char* srcPath1 = kShortSrcPath;
     const char* dstPath0 = prepareOutputFile(OUTPATH(TestPauseResumeSingleClient_Session0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestPauseResumeSingleClient_Session1));

     // Submit one offline session, should start immediately.
     EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kUnspecified,
                                  kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
     // Test get session after starts.
     EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

     // Submit one realtime session.
     EXPECT_TRUE(
             mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));

     // Offline session should pause.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
     EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

     // Realtime session should start immediately, and run to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));

     // Test get session after finish fails.
     EXPECT_TRUE(mClient1->getSession<fail>(1, "", ""));

     // Then offline session should resume.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));
     // Test get session after resume.
     EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

     // Offline session should finish.
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
     // Test get session after finish fails.
     EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));

     unregisterMultipleClients();
 }

 /*
  * Basic test for pause/resume with two clients, with one session each.
  * Top app's session should preempt the other app's session.
  */
 TEST_F(MediaTranscodingServiceRealTest, TestPauseResumeMultiClients) {
     ALOGD("TestPauseResumeMultiClients starting...");

     dismissKeyguard();
     stopAppPackages();

     registerMultipleClients();

     const char* srcPath0 = kLongSrcPath;
     const char* srcPath1 = kShortSrcPath;
     const char* dstPath0 = prepareOutputFile(OUTPATH(TestPauseResumeMultiClients_Client0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestPauseResumeMultiClients_Client1));

     ALOGD("Moving app A to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));

     // Submit session to Client1.
     ALOGD("Submitting session to client1 (app A) ...");
     EXPECT_TRUE(
             mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));

     // Client1's session should start immediately.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));

     ALOGD("Moving app B to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));

     // Client1's session should continue to run, since Client2 (app B) doesn't have any session.
     EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);

     // Submit session to Client2.
     ALOGD("Submitting session to client2 (app B) ...");
     EXPECT_TRUE(
             mClient2->submit(0, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));

     // Client1's session should pause, client2's session should start.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));

     // Client2's session should finish, then Client1's session should resume.
     EXPECT_EQ(mClient2->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(2), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));

     // Client1's session should finish.
     EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

     unregisterMultipleClients();

     stopAppPackages();

     ALOGD("TestPauseResumeMultiClients finished.");
 }

 TEST_F(MediaTranscodingServiceRealTest, TestUidGoneForeground) {
     ALOGD("TestUidGoneForeground starting...");

     dismissKeyguard();
     stopAppPackages();

     registerMultipleClients();

     const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

     // Test kill foreground app, using only 1 uid.
     ALOGD("Moving app A to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));

     // Submit sessions to Client1 (app A).
     ALOGD("Submitting sessions to client1 (app A) ...");
     EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
     EXPECT_TRUE(mClient1->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::NoEvent);

     // Kill app A, expect to see A's session pause followed by B's session start,
     // then A's session cancelled with error code kUidGoneCancelled.
     EXPECT_TRUE(ShellHelper::Stop(kClientPackageA));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 0));
     EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 1));
     EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

     unregisterMultipleClients();

     stopAppPackages();

     ALOGD("TestUidGoneForeground finished.");
 }

 TEST_F(MediaTranscodingServiceRealTest, TestUidGoneForegroundMultiUids) {
     ALOGD("TestUidGoneForegroundMultiUids starting...");

     dismissKeyguard();
     stopAppPackages();

     registerMultipleClients();

     const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

     // Test kill foreground app, using two uids.
     ALOGD("Moving app B to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
     EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
     EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
     // Make app A also requesting session 1.
     EXPECT_TRUE(mClient2->addClientUid(1, mClient1->mClientUid));

     ALOGD("Moving app A to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 1));

     // Kill app A, CLIENT(2)'s session 1 should continue because it's also requested by app B.
     EXPECT_TRUE(ShellHelper::Stop(kClientPackageA));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);

     // Kill app B, sessions should be cancelled.
     EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
     EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 1));
     EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

     unregisterMultipleClients();

     stopAppPackages();

     ALOGD("TestUidGoneForegroundMultiUids finished.");
 }
 TEST_F(MediaTranscodingServiceRealTest, TestUidGoneBackground) {
     ALOGD("TestUidGoneBackground starting...");

     dismissKeyguard();
     stopAppPackages();

     registerMultipleClients();

     const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

     // Test kill background app, using two uids.
     ALOGD("Moving app B to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
     EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
     EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);

     ALOGD("Moving app A to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
     EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));

     // Kill app B, all its sessions should be cancelled.
     EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
     EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 1));
     EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

     unregisterMultipleClients();

     stopAppPackages();

     ALOGD("TestUidGoneBackground finished.");
 }

 TEST_F(MediaTranscodingServiceRealTest, TestUidGoneBackgroundMultiUids) {
     ALOGD("TestUidGoneBackgroundMultiUids starting...");

     dismissKeyguard();
     stopAppPackages();

     registerMultipleClients();

     const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
     const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

     // Test kill background app, using two uids.
     ALOGD("Moving app B to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
     EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
     EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
                                  kBitRate));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
     // Make app A also requesting session 1.
     EXPECT_TRUE(mClient2->addClientUid(1, mClient1->mClientUid));

     ALOGD("Moving app A to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 1));

     // Kill app B, CLIENT(2)'s session 1 should continue to run, session 0 on
     // the other hand should be cancelled.
     EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
     EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

     unregisterMultipleClients();

     stopAppPackages();

     ALOGD("TestUidGoneBackgroundMultiUids finished.");
 }

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

	// Unit Test for MediaTranscodingService.

	//#define LOG_NDEBUG 0
	#define LOG_TAG "MediaTranscodingServiceRealTest"

	#include "MediaTranscodingServiceTestHelper.h"

	/*
	* Tests media transcoding service with real transcoder.
	*
	* Uses the same test assets as the MediaTranscoder unit tests. Before running the test,
	* please make sure to push the test assets to /sdcard:
	*
	* adb push $TOP/frameworks/av/media/libmediatranscoding/transcoder/tests/assets /data/local/tmp/TranscodingTestAssets
	*/
	namespace android {

	namespace media {

	constexpr int64_t kPaddingUs = 1000000;
	constexpr int64_t kSessionWithPaddingUs = 10000000 + kPaddingUs;
	constexpr int32_t kBitRate = 8 * 1000 * 1000; // 8Mbs

	constexpr const char* kShortSrcPath =
	"/data/local/tmp/TranscodingTestAssets/cubicle_avc_480x240_aac_24KHz.mp4";
	constexpr const char* kLongSrcPath = "/data/local/tmp/TranscodingTestAssets/longtest_15s.mp4";

	#define OUTPATH(name) "/data/local/tmp/MediaTranscodingService_" #name ".MP4"

	class MediaTranscodingServiceRealTest : public MediaTranscodingServiceTestBase {
	public:
	MediaTranscodingServiceRealTest() { ALOGI("MediaTranscodingServiceResourceTest created"); }

	virtual ~MediaTranscodingServiceRealTest() {
	ALOGI("MediaTranscodingServiceResourceTest destroyed");
	}
	};

	TEST_F(MediaTranscodingServiceRealTest, TestInvalidSource) {
	registerMultipleClients();

	const char* srcPath = "bad_file_uri";
	const char* dstPath = prepareOutputFile(OUTPATH(TestInvalidSource));

	// Submit one session.
	EXPECT_TRUE(
	mClient1->submit(0, srcPath, dstPath, TranscodingSessionPriority::kNormal, kBitRate));

	// Check expected error.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 0));
	EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kErrorIO);

	unregisterMultipleClients();
	}

	TEST_F(MediaTranscodingServiceRealTest, TestPassthru) {
	registerMultipleClients();

	const char* dstPath = prepareOutputFile(OUTPATH(TestPassthru));

	// Submit one session.
	EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath));

	// Wait for session to finish.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

	unregisterMultipleClients();
	}

	TEST_F(MediaTranscodingServiceRealTest, TestTranscodeVideo) {
	registerMultipleClients();

	const char* dstPath = prepareOutputFile(OUTPATH(TestTranscodeVideo));

	// Submit one session.
	EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath, TranscodingSessionPriority::kNormal,
	kBitRate));

	// Wait for session to finish.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

	unregisterMultipleClients();
	}

	TEST_F(MediaTranscodingServiceRealTest, TestTranscodeVideoProgress) {
	registerMultipleClients();

	const char* dstPath = prepareOutputFile(OUTPATH(TestTranscodeVideoProgress));

	// Submit one session.
	EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath, TranscodingSessionPriority::kNormal,
	kBitRate));

	// Wait for session to finish.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

	// Check the progress update messages are received. For this clip (around ~15 second long),
	// expect at least 10 updates, and the last update should be 100.
	int lastProgress;
	EXPECT_GE(mClient1->getUpdateCount(&lastProgress), 10);
	EXPECT_EQ(lastProgress, 100);

	unregisterMultipleClients();
	}

	/*
	* Test cancel immediately after start.
	*/
	TEST_F(MediaTranscodingServiceRealTest, TestCancelImmediately) {
	registerMultipleClients();

	const char* srcPath0 = kLongSrcPath;
	const char* srcPath1 = kShortSrcPath;
	const char* dstPath0 = prepareOutputFile(OUTPATH(TestCancelImmediately_Session0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestCancelImmediately_Session1));

	// Submit one session, should start immediately.
	EXPECT_TRUE(
	mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
	EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

	// Test cancel session immediately, getSession should fail after cancel.
	EXPECT_TRUE(mClient1->cancel(0));
	EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));

	// Submit new session, new session should start immediately and finish.
	EXPECT_TRUE(
	mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));

	unregisterMultipleClients();
	}

	/*
	* Test cancel in the middle of transcoding.
	*/
	TEST_F(MediaTranscodingServiceRealTest, TestCancelWhileRunning) {
	registerMultipleClients();

	const char* srcPath0 = kLongSrcPath;
	const char* srcPath1 = kShortSrcPath;
	const char* dstPath0 = prepareOutputFile(OUTPATH(TestCancelWhileRunning_Session0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestCancelWhileRunning_Session1));

	// Submit two sessions, session 0 should start immediately, session 1 should be queued.
	EXPECT_TRUE(
	mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
	EXPECT_TRUE(
	mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
	EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
	EXPECT_TRUE(mClient1->getSession(1, srcPath1, dstPath1));

	// Session 0 (longtest) shouldn't finish in 1 seconds.
	EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);

	// Now cancel session 0. Session 1 should start immediately and finish.
	EXPECT_TRUE(mClient1->cancel(0));
	EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));

	unregisterMultipleClients();
	}

	TEST_F(MediaTranscodingServiceRealTest, TestPauseResumeSingleClient) {
	registerMultipleClients();

	const char* srcPath0 = kLongSrcPath;
	const char* srcPath1 = kShortSrcPath;
	const char* dstPath0 = prepareOutputFile(OUTPATH(TestPauseResumeSingleClient_Session0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestPauseResumeSingleClient_Session1));

	// Submit one offline session, should start immediately.
	EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kUnspecified,
	kBitRate));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
	// Test get session after starts.
	EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

	// Submit one realtime session.
	EXPECT_TRUE(
	mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));

	// Offline session should pause.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
	EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

	// Realtime session should start immediately, and run to finish.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));

	// Test get session after finish fails.
	EXPECT_TRUE(mClient1->getSession<fail>(1, "", ""));

	// Then offline session should resume.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));
	// Test get session after resume.
	EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));

	// Offline session should finish.
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
	// Test get session after finish fails.
	EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));

	unregisterMultipleClients();
	}

	/*
	* Basic test for pause/resume with two clients, with one session each.
	* Top app's session should preempt the other app's session.
	*/
	TEST_F(MediaTranscodingServiceRealTest, TestPauseResumeMultiClients) {
	ALOGD("TestPauseResumeMultiClients starting...");

	dismissKeyguard();
	stopAppPackages();

	registerMultipleClients();

	const char* srcPath0 = kLongSrcPath;
	const char* srcPath1 = kShortSrcPath;
	const char* dstPath0 = prepareOutputFile(OUTPATH(TestPauseResumeMultiClients_Client0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestPauseResumeMultiClients_Client1));

	ALOGD("Moving app A to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));

	// Submit session to Client1.
	ALOGD("Submitting session to client1 (app A) ...");
	EXPECT_TRUE(
	mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));

	// Client1's session should start immediately.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));

	ALOGD("Moving app B to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));

	// Client1's session should continue to run, since Client2 (app B) doesn't have any session.
	EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);

	// Submit session to Client2.
	ALOGD("Submitting session to client2 (app B) ...");
	EXPECT_TRUE(
	mClient2->submit(0, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));

	// Client1's session should pause, client2's session should start.
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));

	// Client2's session should finish, then Client1's session should resume.
	EXPECT_EQ(mClient2->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(2), 0));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));

	// Client1's session should finish.
	EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));

	unregisterMultipleClients();

	stopAppPackages();

	ALOGD("TestPauseResumeMultiClients finished.");
	}

	TEST_F(MediaTranscodingServiceRealTest, TestUidGoneForeground) {
	ALOGD("TestUidGoneForeground starting...");

	dismissKeyguard();
	stopAppPackages();

	registerMultipleClients();

	const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

	// Test kill foreground app, using only 1 uid.
	ALOGD("Moving app A to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));

	// Submit sessions to Client1 (app A).
	ALOGD("Submitting sessions to client1 (app A) ...");
	EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
	EXPECT_TRUE(mClient1->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::NoEvent);

	// Kill app A, expect to see A's session pause followed by B's session start,
	// then A's session cancelled with error code kUidGoneCancelled.
	EXPECT_TRUE(ShellHelper::Stop(kClientPackageA));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 0));
	EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 1));
	EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

	unregisterMultipleClients();

	stopAppPackages();

	ALOGD("TestUidGoneForeground finished.");
	}

	TEST_F(MediaTranscodingServiceRealTest, TestUidGoneForegroundMultiUids) {
	ALOGD("TestUidGoneForegroundMultiUids starting...");

	dismissKeyguard();
	stopAppPackages();

	registerMultipleClients();

	const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

	// Test kill foreground app, using two uids.
	ALOGD("Moving app B to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
	EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
	EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
	// Make app A also requesting session 1.
	EXPECT_TRUE(mClient2->addClientUid(1, mClient1->mClientUid));

	ALOGD("Moving app A to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 1));

	// Kill app A, CLIENT(2)'s session 1 should continue because it's also requested by app B.
	EXPECT_TRUE(ShellHelper::Stop(kClientPackageA));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);

	// Kill app B, sessions should be cancelled.
	EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
	EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 1));
	EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

	unregisterMultipleClients();

	stopAppPackages();

	ALOGD("TestUidGoneForegroundMultiUids finished.");
	}
	TEST_F(MediaTranscodingServiceRealTest, TestUidGoneBackground) {
	ALOGD("TestUidGoneBackground starting...");

	dismissKeyguard();
	stopAppPackages();

	registerMultipleClients();

	const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

	// Test kill background app, using two uids.
	ALOGD("Moving app B to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
	EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
	EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);

	ALOGD("Moving app A to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
	EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
	EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));

	// Kill app B, all its sessions should be cancelled.
	EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
	EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 1));
	EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

	unregisterMultipleClients();

	stopAppPackages();

	ALOGD("TestUidGoneBackground finished.");
	}

	TEST_F(MediaTranscodingServiceRealTest, TestUidGoneBackgroundMultiUids) {
	ALOGD("TestUidGoneBackgroundMultiUids starting...");

	dismissKeyguard();
	stopAppPackages();

	registerMultipleClients();

	const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
	const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));

	// Test kill background app, using two uids.
	ALOGD("Moving app B to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
	EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
	EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
	kBitRate));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
	// Make app A also requesting session 1.
	EXPECT_TRUE(mClient2->addClientUid(1, mClient1->mClientUid));

	ALOGD("Moving app A to top...");
	EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 1));

	// Kill app B, CLIENT(2)'s session 1 should continue to run, session 0 on
	// the other hand should be cancelled.
	EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
	EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
	EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);

	unregisterMultipleClients();

	stopAppPackages();

	ALOGD("TestUidGoneBackgroundMultiUids finished.");
	}

	} // namespace media
	} // namespace android