audio/aidl/vts/VtsHalAudioEffectFactoryTargetTest.cpp - LeafOS-Project/android_hardware_interfaces - Gitiles

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

 #include <memory>
 #include <set>
 #include <string>
 #include <vector>

 #define LOG_TAG "VtsHalAudioEffectFactory"

 #include <aidl/Gtest.h>
 #include <aidl/Vintf.h>
 #include <android-base/logging.h>
 #include <android-base/properties.h>
 #include <android/binder_interface_utils.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
 #include <system/audio_effects/effect_uuid.h>

 #include <aidl/android/hardware/audio/effect/IFactory.h>

 #include "EffectFactoryHelper.h"
 #include "TestUtils.h"

 #include <system/audio_aidl_utils.h>

 using namespace android;
 using ::android::audio::utils::toString;

 using namespace android;

 using aidl::android::hardware::audio::effect::Descriptor;
 using aidl::android::hardware::audio::effect::getEffectUuidNull;
 using aidl::android::hardware::audio::effect::getEffectUuidZero;
 using aidl::android::hardware::audio::effect::IEffect;
 using aidl::android::hardware::audio::effect::IFactory;
 using aidl::android::hardware::audio::effect::Processing;
 using aidl::android::media::audio::common::AudioSource;
 using aidl::android::media::audio::common::AudioStreamType;
 using aidl::android::media::audio::common::AudioUuid;
 using android::hardware::audio::common::testing::detail::TestExecutionTracer;

 /// Effect factory testing.
 class EffectFactoryTest : public testing::TestWithParam<std::string> {
   public:
     void SetUp() override {
         mFactoryHelper = std::make_unique<EffectFactoryHelper>(GetParam());
         connectAndGetFactory();
     }

     void TearDown() override {
         for (auto& effect : mEffects) {
             const auto status = mEffectFactory->destroyEffect(effect);
             EXPECT_STATUS(EX_NONE, status);
         }
     }

     std::unique_ptr<EffectFactoryHelper> mFactoryHelper;
     std::shared_ptr<IFactory> mEffectFactory;
     std::vector<std::shared_ptr<IEffect>> mEffects;
     const Descriptor::Identity kNullId = {.uuid = getEffectUuidNull()};
     const Descriptor::Identity kZeroId = {.uuid = getEffectUuidZero()};
     const Descriptor kNullDesc = {.common.id = kNullId};
     const Descriptor kZeroDesc = {.common.id = kZeroId};

     template <typename Functor>
     void ForEachId(const std::vector<Descriptor::Identity> ids, Functor functor) {
         for (const auto& id : ids) {
             SCOPED_TRACE(id.toString());
             functor(id);
         }
     }
     template <typename Functor>
     void ForEachEffect(std::vector<std::shared_ptr<IEffect>> effects, Functor functor) {
         for (auto& effect : effects) {
             functor(effect);
         }
     }

     std::vector<std::shared_ptr<IEffect>> createWithDescs(
             const std::vector<Descriptor> descs, const binder_status_t expectStatus = EX_NONE) {
         std::vector<std::shared_ptr<IEffect>> effects;
         for (const auto& desc : descs) {
             const auto& uuid = desc.common.id.uuid;
             std::shared_ptr<IEffect> effect;
             EXPECT_STATUS(expectStatus, mEffectFactory->createEffect(uuid, &effect));
             if (expectStatus == EX_NONE) {
                 EXPECT_NE(effect, nullptr) << " null effect with uuid: " << toString(uuid);
                 effects.push_back(std::move(effect));
             }
         }
         return effects;
     }
     void destroyEffects(std::vector<std::shared_ptr<IEffect>> effects,
                         const binder_status_t expectStatus = EX_NONE) {
         for (const auto& effect : effects) {
             EXPECT_STATUS(expectStatus, mEffectFactory->destroyEffect(effect));
         }
     }
     void creatAndDestroyDescs(const std::vector<Descriptor> descs) {
         for (const auto& desc : descs) {
             auto effects = createWithDescs({desc});
             ASSERT_NO_FATAL_FAILURE(destroyEffects(effects));
         }
     }
     void connectAndGetFactory() {
         ASSERT_NO_FATAL_FAILURE(mFactoryHelper->ConnectToFactoryService());
         mEffectFactory = mFactoryHelper->GetFactory();
         ASSERT_NE(mEffectFactory, nullptr);
     }
 };

 TEST_P(EffectFactoryTest, SetupAndTearDown) {
     // Intentionally empty test body.
 }

 TEST_P(EffectFactoryTest, CanBeRestarted) {
     ASSERT_NO_FATAL_FAILURE(mFactoryHelper->RestartFactoryService());
 }

 /**
  * @brief Check at least support list of effect must be supported by aosp:
  * https://developer.android.com/reference/android/media/audiofx/AudioEffect
  *
  * For Android 13, they are: Equalizer, LoudnessEnhancer, Visualizer, and DynamicsProcessing.
  * https://source.android.com/docs/compatibility/13/android-13-cdd#552_audio_effects
  */
 TEST_P(EffectFactoryTest, SupportMandatoryEffectTypes) {
     std::vector<Descriptor> descs;
     std::set<AudioUuid> typeUuidSet({
             aidl::android::hardware::audio::effect::getEffectTypeUuidEqualizer(),
             aidl::android::hardware::audio::effect::getEffectTypeUuidDynamicsProcessing(),
             aidl::android::hardware::audio::effect::getEffectTypeUuidLoudnessEnhancer(),
             aidl::android::hardware::audio::effect::getEffectTypeUuidVisualizer(),
     });

     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_TRUE(descs.size() >= typeUuidSet.size());
     for (const auto& desc : descs) {
         typeUuidSet.erase(desc.common.id.type);
     }
     std::string msg = " missing type UUID:\n";
     for (const auto& uuid : typeUuidSet) {
         msg += (toString(uuid) + "\n");
     }
     SCOPED_TRACE(msg);
     EXPECT_EQ(0UL, typeUuidSet.size());
 }

 TEST_P(EffectFactoryTest, QueryNullTypeUuid) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(
             mEffectFactory->queryEffects(getEffectUuidNull(), std::nullopt, std::nullopt, &descs));
     EXPECT_EQ(descs.size(), 0UL);
 }

 TEST_P(EffectFactoryTest, QueriedNullImplUuid) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(
             mEffectFactory->queryEffects(std::nullopt, getEffectUuidNull(), std::nullopt, &descs));
     EXPECT_EQ(descs.size(), 0UL);
 }

 TEST_P(EffectFactoryTest, QueriedNullProxyUuid) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(
             mEffectFactory->queryEffects(std::nullopt, std::nullopt, getEffectUuidNull(), &descs));
     EXPECT_EQ(descs.size(), 0UL);
 }

 // create all effects, and then destroy them all together
 TEST_P(EffectFactoryTest, CreateAndDestroyEffects) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_NE(descs.size(), 0UL);

     std::vector<std::shared_ptr<IEffect>> effects;
     effects = createWithDescs(descs);
     EXPECT_EQ(descs.size(), effects.size());
     destroyEffects(effects);
 }

 TEST_P(EffectFactoryTest, CreateMultipleInstanceOfSameEffect) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_NE(descs.size(), 0UL);

     std::vector<std::shared_ptr<IEffect>> effects = createWithDescs(descs);
     EXPECT_EQ(descs.size(), effects.size());
     std::vector<std::shared_ptr<IEffect>> effects2 = createWithDescs(descs);
     EXPECT_EQ(descs.size(), effects2.size());
     std::vector<std::shared_ptr<IEffect>> effects3 = createWithDescs(descs);
     EXPECT_EQ(descs.size(), effects3.size());

     destroyEffects(effects);
     destroyEffects(effects2);
     destroyEffects(effects3);
 }

 // create and destroy each effect one by one
 TEST_P(EffectFactoryTest, CreateAndDestroyEffectsOneByOne) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_NE(descs.size(), 0UL);

     creatAndDestroyDescs(descs);
 }

 // for each effect: repeat 3 times create and destroy
 TEST_P(EffectFactoryTest, CreateAndDestroyRepeat) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_NE(descs.size(), 0UL);

     creatAndDestroyDescs(descs);
     creatAndDestroyDescs(descs);
     creatAndDestroyDescs(descs);
 }

 // Expect EX_ILLEGAL_ARGUMENT when create with invalid UUID.
 TEST_P(EffectFactoryTest, CreateWithInvalidUuid) {
     std::vector<Descriptor> descs = {kNullDesc, kZeroDesc};
     auto effects = createWithDescs(descs, EX_ILLEGAL_ARGUMENT);
     EXPECT_EQ(effects.size(), 0UL);
 }

 // Expect EX_ILLEGAL_ARGUMENT when destroy null interface.
 TEST_P(EffectFactoryTest, DestroyWithInvalidInterface) {
     std::shared_ptr<IEffect> spDummyEffect(nullptr);
     destroyEffects({spDummyEffect}, EX_ILLEGAL_ARGUMENT);
 }

 // Same descriptor ID should work after service restart.
 TEST_P(EffectFactoryTest, CreateDestroyWithRestart) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_NE(descs.size(), 0UL);
     creatAndDestroyDescs(descs);

     mFactoryHelper->RestartFactoryService();

     connectAndGetFactory();
     creatAndDestroyDescs(descs);
 }

 // Effect handle invalid after restart.
 TEST_P(EffectFactoryTest, EffectInvalidAfterRestart) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_NE(descs.size(), 0UL);
     std::vector<std::shared_ptr<IEffect>> effects = createWithDescs(descs);

     ASSERT_NO_FATAL_FAILURE(mFactoryHelper->RestartFactoryService());

     connectAndGetFactory();
     destroyEffects(effects, EX_ILLEGAL_ARGUMENT);
 }

 // expect no error with the queryProcessing interface, but don't check number of processing
 TEST_P(EffectFactoryTest, QueryProcess) {
     std::vector<Processing> processing;
     EXPECT_IS_OK(mEffectFactory->queryProcessing(std::nullopt, &processing));
     std::set<Processing> processingSet(processing.begin(), processing.end());

     Processing::Type streamType =
             Processing::Type::make<Processing::Type::streamType>(AudioStreamType::SYSTEM);
     std::vector<Processing> processingFilteredByStream;
     EXPECT_IS_OK(mEffectFactory->queryProcessing(streamType, &processingFilteredByStream));

     Processing::Type source =
             Processing::Type::make<Processing::Type::source>(AudioSource::DEFAULT);
     std::vector<Processing> processingFilteredBySource;
     EXPECT_IS_OK(mEffectFactory->queryProcessing(source, &processingFilteredBySource));

     EXPECT_TRUE(processing.size() >= processingFilteredByStream.size());
     EXPECT_TRUE(std::all_of(
             processingFilteredByStream.begin(), processingFilteredByStream.end(),
             [&](const auto& proc) { return processingSet.find(proc) != processingSet.end(); }));

     EXPECT_TRUE(processing.size() >= processingFilteredBySource.size());
     EXPECT_TRUE(std::all_of(
             processingFilteredBySource.begin(), processingFilteredBySource.end(),
             [&](const auto& proc) { return processingSet.find(proc) != processingSet.end(); }));
 }

 // Make sure all effect instances have same HAL version number as IFactory.
 TEST_P(EffectFactoryTest, VersionNumberForAllEffectsEqualsToIFactory) {
     std::vector<Descriptor> descs;
     EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
     EXPECT_NE(descs.size(), 0UL);

     std::vector<std::shared_ptr<IEffect>> effects = createWithDescs(descs);
     int factoryVersion = 0;
     EXPECT_IS_OK(mEffectFactory->getInterfaceVersion(&factoryVersion));

     for (const auto& effect : effects) {
         int effectVersion = 0;
         EXPECT_NE(nullptr, effect);
         EXPECT_IS_OK(effect->getInterfaceVersion(&effectVersion));
         EXPECT_EQ(factoryVersion, effectVersion);
     }
     ASSERT_NO_FATAL_FAILURE(destroyEffects(effects));
 }

 INSTANTIATE_TEST_SUITE_P(EffectFactoryTest, EffectFactoryTest,
                          testing::ValuesIn(android::getAidlHalInstanceNames(IFactory::descriptor)),
                          android::PrintInstanceNameToString);
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EffectFactoryTest);

 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
     ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
     ABinderProcess_setThreadPoolMaxThreadCount(1);
     ABinderProcess_startThreadPool();
     return RUN_ALL_TESTS();
 }
	/*
	* Copyright (C) 2022 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.
	*/

	#include <memory>
	#include <set>
	#include <string>
	#include <vector>

	#define LOG_TAG "VtsHalAudioEffectFactory"

	#include <aidl/Gtest.h>
	#include <aidl/Vintf.h>
	#include <android-base/logging.h>
	#include <android-base/properties.h>
	#include <android/binder_interface_utils.h>
	#include <android/binder_manager.h>
	#include <android/binder_process.h>
	#include <system/audio_effects/effect_uuid.h>

	#include <aidl/android/hardware/audio/effect/IFactory.h>

	#include "EffectFactoryHelper.h"
	#include "TestUtils.h"

	#include <system/audio_aidl_utils.h>

	using namespace android;
	using ::android::audio::utils::toString;

	using namespace android;

	using aidl::android::hardware::audio::effect::Descriptor;
	using aidl::android::hardware::audio::effect::getEffectUuidNull;
	using aidl::android::hardware::audio::effect::getEffectUuidZero;
	using aidl::android::hardware::audio::effect::IEffect;
	using aidl::android::hardware::audio::effect::IFactory;
	using aidl::android::hardware::audio::effect::Processing;
	using aidl::android::media::audio::common::AudioSource;
	using aidl::android::media::audio::common::AudioStreamType;
	using aidl::android::media::audio::common::AudioUuid;
	using android::hardware::audio::common::testing::detail::TestExecutionTracer;

	/// Effect factory testing.
	class EffectFactoryTest : public testing::TestWithParam<std::string> {
	public:
	void SetUp() override {
	mFactoryHelper = std::make_unique<EffectFactoryHelper>(GetParam());
	connectAndGetFactory();
	}

	void TearDown() override {
	for (auto& effect : mEffects) {
	const auto status = mEffectFactory->destroyEffect(effect);
	EXPECT_STATUS(EX_NONE, status);
	}
	}

	std::unique_ptr<EffectFactoryHelper> mFactoryHelper;
	std::shared_ptr<IFactory> mEffectFactory;
	std::vector<std::shared_ptr<IEffect>> mEffects;
	const Descriptor::Identity kNullId = {.uuid = getEffectUuidNull()};
	const Descriptor::Identity kZeroId = {.uuid = getEffectUuidZero()};
	const Descriptor kNullDesc = {.common.id = kNullId};
	const Descriptor kZeroDesc = {.common.id = kZeroId};

	template <typename Functor>
	void ForEachId(const std::vector<Descriptor::Identity> ids, Functor functor) {
	for (const auto& id : ids) {
	SCOPED_TRACE(id.toString());
	functor(id);
	}
	}
	template <typename Functor>
	void ForEachEffect(std::vector<std::shared_ptr<IEffect>> effects, Functor functor) {
	for (auto& effect : effects) {
	functor(effect);
	}
	}

	std::vector<std::shared_ptr<IEffect>> createWithDescs(
	const std::vector<Descriptor> descs, const binder_status_t expectStatus = EX_NONE) {
	std::vector<std::shared_ptr<IEffect>> effects;
	for (const auto& desc : descs) {
	const auto& uuid = desc.common.id.uuid;
	std::shared_ptr<IEffect> effect;
	EXPECT_STATUS(expectStatus, mEffectFactory->createEffect(uuid, &effect));
	if (expectStatus == EX_NONE) {
	EXPECT_NE(effect, nullptr) << " null effect with uuid: " << toString(uuid);
	effects.push_back(std::move(effect));
	}
	}
	return effects;
	}
	void destroyEffects(std::vector<std::shared_ptr<IEffect>> effects,
	const binder_status_t expectStatus = EX_NONE) {
	for (const auto& effect : effects) {
	EXPECT_STATUS(expectStatus, mEffectFactory->destroyEffect(effect));
	}
	}
	void creatAndDestroyDescs(const std::vector<Descriptor> descs) {
	for (const auto& desc : descs) {
	auto effects = createWithDescs({desc});
	ASSERT_NO_FATAL_FAILURE(destroyEffects(effects));
	}
	}
	void connectAndGetFactory() {
	ASSERT_NO_FATAL_FAILURE(mFactoryHelper->ConnectToFactoryService());
	mEffectFactory = mFactoryHelper->GetFactory();
	ASSERT_NE(mEffectFactory, nullptr);
	}
	};

	TEST_P(EffectFactoryTest, SetupAndTearDown) {
	// Intentionally empty test body.
	}

	TEST_P(EffectFactoryTest, CanBeRestarted) {
	ASSERT_NO_FATAL_FAILURE(mFactoryHelper->RestartFactoryService());
	}

	/**
	* @brief Check at least support list of effect must be supported by aosp:
	* https://developer.android.com/reference/android/media/audiofx/AudioEffect
	*
	* For Android 13, they are: Equalizer, LoudnessEnhancer, Visualizer, and DynamicsProcessing.
	* https://source.android.com/docs/compatibility/13/android-13-cdd#552_audio_effects
	*/
	TEST_P(EffectFactoryTest, SupportMandatoryEffectTypes) {
	std::vector<Descriptor> descs;
	std::set<AudioUuid> typeUuidSet({
	aidl::android::hardware::audio::effect::getEffectTypeUuidEqualizer(),
	aidl::android::hardware::audio::effect::getEffectTypeUuidDynamicsProcessing(),
	aidl::android::hardware::audio::effect::getEffectTypeUuidLoudnessEnhancer(),
	aidl::android::hardware::audio::effect::getEffectTypeUuidVisualizer(),
	});

	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_TRUE(descs.size() >= typeUuidSet.size());
	for (const auto& desc : descs) {
	typeUuidSet.erase(desc.common.id.type);
	}
	std::string msg = " missing type UUID:\n";
	for (const auto& uuid : typeUuidSet) {
	msg += (toString(uuid) + "\n");
	}
	SCOPED_TRACE(msg);
	EXPECT_EQ(0UL, typeUuidSet.size());
	}

	TEST_P(EffectFactoryTest, QueryNullTypeUuid) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(
	mEffectFactory->queryEffects(getEffectUuidNull(), std::nullopt, std::nullopt, &descs));
	EXPECT_EQ(descs.size(), 0UL);
	}

	TEST_P(EffectFactoryTest, QueriedNullImplUuid) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(
	mEffectFactory->queryEffects(std::nullopt, getEffectUuidNull(), std::nullopt, &descs));
	EXPECT_EQ(descs.size(), 0UL);
	}

	TEST_P(EffectFactoryTest, QueriedNullProxyUuid) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(
	mEffectFactory->queryEffects(std::nullopt, std::nullopt, getEffectUuidNull(), &descs));
	EXPECT_EQ(descs.size(), 0UL);
	}

	// create all effects, and then destroy them all together
	TEST_P(EffectFactoryTest, CreateAndDestroyEffects) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_NE(descs.size(), 0UL);

	std::vector<std::shared_ptr<IEffect>> effects;
	effects = createWithDescs(descs);
	EXPECT_EQ(descs.size(), effects.size());
	destroyEffects(effects);
	}

	TEST_P(EffectFactoryTest, CreateMultipleInstanceOfSameEffect) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_NE(descs.size(), 0UL);

	std::vector<std::shared_ptr<IEffect>> effects = createWithDescs(descs);
	EXPECT_EQ(descs.size(), effects.size());
	std::vector<std::shared_ptr<IEffect>> effects2 = createWithDescs(descs);
	EXPECT_EQ(descs.size(), effects2.size());
	std::vector<std::shared_ptr<IEffect>> effects3 = createWithDescs(descs);
	EXPECT_EQ(descs.size(), effects3.size());

	destroyEffects(effects);
	destroyEffects(effects2);
	destroyEffects(effects3);
	}

	// create and destroy each effect one by one
	TEST_P(EffectFactoryTest, CreateAndDestroyEffectsOneByOne) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_NE(descs.size(), 0UL);

	creatAndDestroyDescs(descs);
	}

	// for each effect: repeat 3 times create and destroy
	TEST_P(EffectFactoryTest, CreateAndDestroyRepeat) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_NE(descs.size(), 0UL);

	creatAndDestroyDescs(descs);
	creatAndDestroyDescs(descs);
	creatAndDestroyDescs(descs);
	}

	// Expect EX_ILLEGAL_ARGUMENT when create with invalid UUID.
	TEST_P(EffectFactoryTest, CreateWithInvalidUuid) {
	std::vector<Descriptor> descs = {kNullDesc, kZeroDesc};
	auto effects = createWithDescs(descs, EX_ILLEGAL_ARGUMENT);
	EXPECT_EQ(effects.size(), 0UL);
	}

	// Expect EX_ILLEGAL_ARGUMENT when destroy null interface.
	TEST_P(EffectFactoryTest, DestroyWithInvalidInterface) {
	std::shared_ptr<IEffect> spDummyEffect(nullptr);
	destroyEffects({spDummyEffect}, EX_ILLEGAL_ARGUMENT);
	}

	// Same descriptor ID should work after service restart.
	TEST_P(EffectFactoryTest, CreateDestroyWithRestart) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_NE(descs.size(), 0UL);
	creatAndDestroyDescs(descs);

	mFactoryHelper->RestartFactoryService();

	connectAndGetFactory();
	creatAndDestroyDescs(descs);
	}

	// Effect handle invalid after restart.
	TEST_P(EffectFactoryTest, EffectInvalidAfterRestart) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_NE(descs.size(), 0UL);
	std::vector<std::shared_ptr<IEffect>> effects = createWithDescs(descs);

	ASSERT_NO_FATAL_FAILURE(mFactoryHelper->RestartFactoryService());

	connectAndGetFactory();
	destroyEffects(effects, EX_ILLEGAL_ARGUMENT);
	}

	// expect no error with the queryProcessing interface, but don't check number of processing
	TEST_P(EffectFactoryTest, QueryProcess) {
	std::vector<Processing> processing;
	EXPECT_IS_OK(mEffectFactory->queryProcessing(std::nullopt, &processing));
	std::set<Processing> processingSet(processing.begin(), processing.end());

	Processing::Type streamType =
	Processing::Type::make<Processing::Type::streamType>(AudioStreamType::SYSTEM);
	std::vector<Processing> processingFilteredByStream;
	EXPECT_IS_OK(mEffectFactory->queryProcessing(streamType, &processingFilteredByStream));

	Processing::Type source =
	Processing::Type::make<Processing::Type::source>(AudioSource::DEFAULT);
	std::vector<Processing> processingFilteredBySource;
	EXPECT_IS_OK(mEffectFactory->queryProcessing(source, &processingFilteredBySource));

	EXPECT_TRUE(processing.size() >= processingFilteredByStream.size());
	EXPECT_TRUE(std::all_of(
	processingFilteredByStream.begin(), processingFilteredByStream.end(),
	[&](const auto& proc) { return processingSet.find(proc) != processingSet.end(); }));

	EXPECT_TRUE(processing.size() >= processingFilteredBySource.size());
	EXPECT_TRUE(std::all_of(
	processingFilteredBySource.begin(), processingFilteredBySource.end(),
	[&](const auto& proc) { return processingSet.find(proc) != processingSet.end(); }));
	}

	// Make sure all effect instances have same HAL version number as IFactory.
	TEST_P(EffectFactoryTest, VersionNumberForAllEffectsEqualsToIFactory) {
	std::vector<Descriptor> descs;
	EXPECT_IS_OK(mEffectFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &descs));
	EXPECT_NE(descs.size(), 0UL);

	std::vector<std::shared_ptr<IEffect>> effects = createWithDescs(descs);
	int factoryVersion = 0;
	EXPECT_IS_OK(mEffectFactory->getInterfaceVersion(&factoryVersion));

	for (const auto& effect : effects) {
	int effectVersion = 0;
	EXPECT_NE(nullptr, effect);
	EXPECT_IS_OK(effect->getInterfaceVersion(&effectVersion));
	EXPECT_EQ(factoryVersion, effectVersion);
	}
	ASSERT_NO_FATAL_FAILURE(destroyEffects(effects));
	}

	INSTANTIATE_TEST_SUITE_P(EffectFactoryTest, EffectFactoryTest,
	testing::ValuesIn(android::getAidlHalInstanceNames(IFactory::descriptor)),
	android::PrintInstanceNameToString);
	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EffectFactoryTest);

	int main(int argc, char** argv) {
	::testing::InitGoogleTest(&argc, argv);
	::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
	ABinderProcess_setThreadPoolMaxThreadCount(1);
	ABinderProcess_startThreadPool();
	return RUN_ALL_TESTS();
	}