Merge "Audio VTS: Create utility lib" (213a897d) · Commits · e / os / android_hardware_interfaces

audio/2.0/vts/functional/Android.bp

+2 −2

Original line number	Diff line number	Diff line
		@@ -18,8 +18,7 @@ cc_test {
		name: "VtsHalAudioV2_0TargetTest",
		defaults: ["hidl_defaults"],
		srcs: ["AudioPrimaryHidlHalTest.cpp",
		"ValidateAudioConfiguration.cpp",
		"utility/ValidateXml.cpp"],
		"ValidateAudioConfiguration.cpp"],
		shared_libs: [
		"libbase",
		"liblog",
		@@ -30,6 +29,7 @@ cc_test {
		"libxml2",
		"android.hardware.audio@2.0",
		"android.hardware.audio.common@2.0",
		"android.hardware.audio.common.test.utility",
		],
		static_libs: ["VtsHalHidlTargetTestBase"],
		cflags: [

audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp

+4 −59

Original line number	Diff line number	Diff line
		@@ -21,9 +21,7 @@
		#include <cstddef>
		#include <cstdio>
		#include <limits>
		#include <list>
		#include <string>
		#include <type_traits>
		#include <vector>

		#include <VtsHalHidlTargetTestBase.h>
		@@ -37,6 +35,8 @@
		#include <android/hardware/audio/common/2.0/types.h>

		#include "utility/AssertOk.h"
		#include "utility/Documentation.h"
		#include "utility/EnvironmentTearDown.h"
		#include "utility/PrettyPrintAudioTypes.h"
		#include "utility/ReturnIn.h"

		@@ -59,8 +59,7 @@ using ::android::hardware::audio::V2_0::IDevicesFactory;
		using ::android::hardware::audio::V2_0::IStream;
		using ::android::hardware::audio::V2_0::IStreamIn;
		using ::android::hardware::audio::V2_0::TimeSpec;
		using ReadParameters =
		::android::hardware::audio::V2_0::IStreamIn::ReadParameters;
		using ReadParameters = ::android::hardware::audio::V2_0::IStreamIn::ReadParameters;
		using ReadStatus = ::android::hardware::audio::V2_0::IStreamIn::ReadStatus;
		using ::android::hardware::audio::V2_0::IStreamOut;
		using ::android::hardware::audio::V2_0::IStreamOutCallback;
		@@ -81,61 +80,8 @@ using ::android::hardware::audio::common::V2_0::AudioOutputFlag;
		using ::android::hardware::audio::common::V2_0::AudioSource;
		using ::android::hardware::audio::common::V2_0::ThreadInfo;

		using utility::returnIn;
		using namespace ::android::hardware::audio::common::test::utility;

		const char* getTestName() {
		return ::testing::UnitTest::GetInstance()->current_test_info()->name();
		}

		namespace doc {
		/** Document the current test case.
		* Eg: calling `doc::test("Dump the state of the hal")` in the "debugDump" test
		* will output:
		* <testcase name="debugDump" status="run" time="6"
		* classname="AudioPrimaryHidlTest"
		description="Dump the state of the hal." />
		* see
		https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuide.md#logging-additional-information
		*/
		void test(const std::string& testCaseDocumentation) {
		::testing::Test::RecordProperty("description", testCaseDocumentation);
		}

		/** Document why a test was not fully run. Usually due to an optional feature
		* not implemented. */
		void partialTest(const std::string& reason) {
		LOG(INFO) << "Test " << getTestName() << " partially run: " << reason;
		::testing::Test::RecordProperty("partialyRunTest", reason);
		}

		/** Add a note to the test. */
		void note(const std::string& note) {
		LOG(INFO) << "Test " << getTestName() << " noted: " << note;
		::testing::Test::RecordProperty("note", note);
		}
		}

		// Register callback for static object destruction
		// Avoid destroying static objects after main return.
		// Post main return destruction leads to incorrect gtest timing measurements as
		// well as harder
		// debuging if anything goes wrong during destruction.
		class Environment : public ::testing::Environment {
		public:
		using TearDownFunc = std::function<void()>;
		void registerTearDown(TearDownFunc&& tearDown) {
		tearDowns.push_back(std::move(tearDown));
		}

		private:
		void TearDown() override {
		// Call the tear downs in reverse order of insertion
		for (auto& tearDown : tearDowns) {
		tearDown();
		}
		}
		std::list<TearDownFunc> tearDowns;
		};
		// Instance to register global tearDown
		static Environment* environment;

		@@ -1402,6 +1348,5 @@ int main(int argc, char** argv) {
		::testing::AddGlobalTestEnvironment(environment);
		::testing::InitGoogleTest(&argc, argv);
		int status = RUN_ALL_TESTS();
		LOG(INFO) << "Test result = " << status;
		return status;
		}

audio/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@ subdirs = [
		"2.0/vts/functional",
		"common/2.0",
		"common/2.0/default",
		"common/test/utility",
		"effect/2.0",
		"effect/2.0/vts/functional",
		]

audio/common/test/utility/Android.bp

0 → 100644

+32 −0

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2017 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.
		//

		cc_library_shared {
		name: "android.hardware.audio.common.test.utility",
		defaults : ["hidl_defaults"],
		srcs: ["src/ValidateXml.cpp"],
		cflags: [
		"-O0",
		"-g",
		"-Wextra",
		],
		local_include_dirs: ["include/utility"],
		export_include_dirs: ["include"],
		shared_libs: ["libxml2", "liblog"],
		static_libs: ["libgtest"],
		export_static_lib_headers: ["libgtest"],
		}

audio/2.0/vts/functional/utility/AssertOk.h→audio/common/test/utility/include/utility/AssertOk.h

+42 −42

Original line number	Diff line number	Diff line
		@@ -13,12 +13,21 @@
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		#ifndef ANDROID_HARDWARE_AUDIO_COMMON_TEST_UTILITY_ASSERTOK_H
		#define ANDROID_HARDWARE_AUDIO_COMMON_TEST_UTILITY_ASSERTOK_H

		#include <algorithm>
		#include <vector>

		#include <hidl/Status.h>

		namespace android {
		namespace hardware {
		namespace audio {
		namespace common {
		namespace test {
		namespace utility {

		namespace detail {

		// This is a detail namespace, thus it is OK to import a class as nobody else is
		@@ -27,81 +36,65 @@ using ::android::hardware::Return;
		using ::android::hardware::audio::V2_0::Result;

		template <class T>
		inline ::testing::AssertionResult assertIsOk(const char* expr,
		const Return<T>& ret) {
		inline ::testing::AssertionResult assertIsOk(const char* expr, const Return<T>& ret) {
		return ::testing::AssertionResult(ret.isOk())
		<< "Expected: " << expr
		<< "\n to be an OK Return but it is not: " << ret.description();
		<< "Expected: " << expr << "\n to be an OK Return but it is not: " << ret.description();
		}

		// Call continuation if the provided result isOk
		template <class T, class Continuation>
		inline ::testing::AssertionResult continueIfIsOk(const char* expr,
		const Return<T>& ret,
		inline ::testing::AssertionResult continueIfIsOk(const char* expr, const Return<T>& ret,
		Continuation continuation) {
		auto isOkStatus = assertIsOk(expr, ret);
		return !isOkStatus ? isOkStatus : continuation();
		}

		// Expect two equal Results
		inline ::testing::AssertionResult assertResult(const char* e_expr,
		const char* r_expr,
		inline ::testing::AssertionResult assertResult(const char* e_expr, const char* r_expr,
		Result expected, Result result) {
		return ::testing::AssertionResult(expected == result)
		<< "Value of: " << r_expr
		<< "\n Actual: " << ::testing::PrintToString(result)
		<< "\nExpected: " << e_expr
		<< "\nWhich is: " << ::testing::PrintToString(expected);
		<< "Value of: " << r_expr << "\n Actual: " << ::testing::PrintToString(result)
		<< "\nExpected: " << e_expr << "\nWhich is: " << ::testing::PrintToString(expected);
		}

		// Expect two equal Results one being wrapped in an OK Return
		inline ::testing::AssertionResult assertResult(const char* e_expr,
		const char* r_expr,
		Result expected,
		const Return<Result>& ret) {
		return continueIfIsOk(r_expr, ret, [&] {
		return assertResult(e_expr, r_expr, expected, Result{ret});
		});
		inline ::testing::AssertionResult assertResult(const char* e_expr, const char* r_expr,
		Result expected, const Return<Result>& ret) {
		return continueIfIsOk(r_expr, ret,
		[&] { return assertResult(e_expr, r_expr, expected, Result{ret}); });
		}

		// Expect a Result to be part of a list of Results
		inline ::testing::AssertionResult assertResult(
		const char* e_expr, const char* r_expr, const std::vector<Result>& expected,
		Result result) {
		inline ::testing::AssertionResult assertResult(const char* e_expr, const char* r_expr,
		const std::vector<Result>& expected, Result result) {
		if (std::find(expected.begin(), expected.end(), result) != expected.end()) {
		return ::testing::AssertionSuccess(); // result is in expected
		}
		return ::testing::AssertionFailure()
		<< "Value of: " << r_expr
		<< "\n Actual: " << ::testing::PrintToString(result)
		<< "Value of: " << r_expr << "\n Actual: " << ::testing::PrintToString(result)
		<< "\nExpected one of: " << e_expr
		<< "\n Which is: " << ::testing::PrintToString(expected);
		}

		// Expect a Result wrapped in an OK Return to be part of a list of Results
		inline ::testing::AssertionResult assertResult(
		const char* e_expr, const char* r_expr, const std::vector<Result>& expected,
		inline ::testing::AssertionResult assertResult(const char* e_expr, const char* r_expr,
		const std::vector<Result>& expected,
		const Return<Result>& ret) {
		return continueIfIsOk(r_expr, ret, [&] {
		return assertResult(e_expr, r_expr, expected, Result{ret});
		});
		return continueIfIsOk(r_expr, ret,
		[&] { return assertResult(e_expr, r_expr, expected, Result{ret}); });
		}

		inline ::testing::AssertionResult assertOk(const char* expr,
		const Return<void>& ret) {
		inline ::testing::AssertionResult assertOk(const char* expr, const Return<void>& ret) {
		return assertIsOk(expr, ret);
		}

		inline ::testing::AssertionResult assertOk(const char* expr, Result result) {
		return ::testing::AssertionResult(result == Result::OK)
		<< "Expected success: " << expr
		<< "\nActual: " << ::testing::PrintToString(result);
		<< "Expected success: " << expr << "\nActual: " << ::testing::PrintToString(result);
		}

		inline ::testing::AssertionResult assertOk(const char* expr,
		const Return<Result>& ret) {
		return continueIfIsOk(expr, ret,
		[&] { return assertOk(expr, Result{ret}); });
		inline ::testing::AssertionResult assertOk(const char* expr, const Return<Result>& ret) {
		return continueIfIsOk(expr, ret, [&] { return assertOk(expr, Result{ret}); });
		}
		}

		@@ -112,7 +105,14 @@ inline ::testing::AssertionResult assertOk(const char* expr,
		#define ASSERT_OK(ret) ASSERT_PRED_FORMAT1(detail::assertOk, ret)
		#define EXPECT_OK(ret) EXPECT_PRED_FORMAT1(detail::assertOk, ret)

		#define ASSERT_RESULT(expected, ret) \
		ASSERT_PRED_FORMAT2(detail::assertResult, expected, ret)
		#define EXPECT_RESULT(expected, ret) \
		EXPECT_PRED_FORMAT2(detail::assertResult, expected, ret)
		#define ASSERT_RESULT(expected, ret) ASSERT_PRED_FORMAT2(detail::assertResult, expected, ret)
		#define EXPECT_RESULT(expected, ret) EXPECT_PRED_FORMAT2(detail::assertResult, expected, ret)

		} // utility
		} // test
		} // common
		} // audio
		} // test
		} // utility

		#endif // ANDROID_HARDWARE_AUDIO_COMMON_TEST_UTILITY_ASSERTOK_H