Merge "Move utility classes in a separate static target" (bd513e06) · Commits · e / os / android_hardware_interfaces

graphics/composer/2.1/vts/functional/Android.bp

+12 −2

Original line number	Diff line number	Diff line
		@@ -17,9 +17,18 @@
		cc_library_static {
		name: "libVtsHalGraphicsComposerTestUtils",
		defaults: ["hidl_defaults"],
		srcs: ["VtsHalGraphicsComposerTestUtils.cpp"],
		shared_libs: ["android.hardware.graphics.composer@2.1"],
		srcs: [
		"GraphicsComposerCallback.cpp",
		"TestCommandReader.cpp",
		"VtsHalGraphicsComposerTestUtils.cpp",
		],
		shared_libs: [
		"android.hardware.graphics.composer@2.1",
		"libfmq",
		"libsync",
		],
		static_libs: [
		"libhwcomposer-command-buffer",
		"VtsHalHidlTargetTestBase",
		],
		cflags: [
		@@ -28,6 +37,7 @@ cc_library_static {
		"-Werror",
		"-O0",
		"-g",
		"-DLOG_TAG=\"GraphicsComposerTestUtils\"",
		],
		export_include_dirs: ["."],
		}

graphics/composer/2.1/vts/functional/GraphicsComposerCallback.cpp

0 → 100644

+93 −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.
		*/

		#include "GraphicsComposerCallback.h"

		namespace android {
		namespace hardware {
		namespace graphics {
		namespace composer {
		namespace V2_1 {
		namespace tests {

		void GraphicsComposerCallback::setVsyncAllowed(bool allowed) {
		std::lock_guard<std::mutex> lock(mMutex);
		mVsyncAllowed = allowed;
		}

		std::vector<Display> GraphicsComposerCallback::getDisplays() const {
		std::lock_guard<std::mutex> lock(mMutex);
		return std::vector<Display>(mDisplays.begin(), mDisplays.end());
		}

		int GraphicsComposerCallback::getInvalidHotplugCount() const {
		std::lock_guard<std::mutex> lock(mMutex);
		return mInvalidHotplugCount;
		}

		int GraphicsComposerCallback::getInvalidRefreshCount() const {
		std::lock_guard<std::mutex> lock(mMutex);
		return mInvalidRefreshCount;
		}

		int GraphicsComposerCallback::getInvalidVsyncCount() const {
		std::lock_guard<std::mutex> lock(mMutex);
		return mInvalidVsyncCount;
		}

		Return<void> GraphicsComposerCallback::onHotplug(Display display,
		Connection connection) {
		std::lock_guard<std::mutex> lock(mMutex);

		if (connection == Connection::CONNECTED) {
		if (!mDisplays.insert(display).second) {
		mInvalidHotplugCount++;
		}
		} else if (connection == Connection::DISCONNECTED) {
		if (!mDisplays.erase(display)) {
		mInvalidHotplugCount++;
		}
		}

		return Void();
		}

		Return<void> GraphicsComposerCallback::onRefresh(Display display) {
		std::lock_guard<std::mutex> lock(mMutex);

		if (mDisplays.count(display) == 0) {
		mInvalidRefreshCount++;
		}

		return Void();
		}

		Return<void> GraphicsComposerCallback::onVsync(Display display, int64_t) {
		std::lock_guard<std::mutex> lock(mMutex);

		if (!mVsyncAllowed \|\| mDisplays.count(display) == 0) {
		mInvalidVsyncCount++;
		}

		return Void();
		}

		} // namespace tests
		} // namespace V2_1
		} // namespace composer
		} // namespace graphics
		} // namespace hardware
		} // namespace android

graphics/composer/2.1/vts/functional/GraphicsComposerCallback.h

0 → 100644

+69 −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.
		*/

		#ifndef GRAPHICS_COMPOSER_CALLBACK_H
		#define GRAPHICS_COMPOSER_CALLBACK_H

		#include <android/hardware/graphics/composer/2.1/IComposerCallback.h>

		#include <mutex>
		#include <unordered_set>

		namespace android {
		namespace hardware {
		namespace graphics {
		namespace composer {
		namespace V2_1 {
		namespace tests {

		// IComposerCallback to be installed with IComposerClient::registerCallback.
		class GraphicsComposerCallback : public IComposerCallback {
		public:
		void setVsyncAllowed(bool allowed);

		std::vector<Display> getDisplays() const;

		int getInvalidHotplugCount() const;

		int getInvalidRefreshCount() const;

		int getInvalidVsyncCount() const;

		private:
		Return<void> onHotplug(Display display, Connection connection) override;
		Return<void> onRefresh(Display display) override;
		Return<void> onVsync(Display display, int64_t) override;

		mutable std::mutex mMutex;
		// the set of all currently connected displays
		std::unordered_set<Display> mDisplays;
		// true only when vsync is enabled
		bool mVsyncAllowed = false;

		// track invalid callbacks
		int mInvalidHotplugCount = 0;
		int mInvalidRefreshCount = 0;
		int mInvalidVsyncCount = 0;
		};

		} // namespace tests
		} // namespace V2_1
		} // namespace composer
		} // namespace graphics
		} // namespace hardware
		} // namespace android

		#endif // GRAPHICS_COMPOSER_CALLBACK_H

graphics/composer/2.1/vts/functional/TestCommandReader.cpp

0 → 100644

+62 −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.
		*/

		#include "TestCommandReader.h"

		#include <gtest/gtest.h>

		namespace android {
		namespace hardware {
		namespace graphics {
		namespace composer {
		namespace V2_1 {
		namespace tests {

		void TestCommandReader::parse() {
		while (!isEmpty()) {
		IComposerClient::Command command;
		uint16_t length;
		ASSERT_TRUE(beginCommand(&command, &length));

		switch (command) {
		case IComposerClient::Command::SET_ERROR: {
		ASSERT_EQ(2, length);
		auto loc = read();
		auto err = readSigned();
		GTEST_FAIL() << "unexpected error " << err << " at location " << loc;
		} break;
		case IComposerClient::Command::SELECT_DISPLAY:
		case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
		case IComposerClient::Command::SET_DISPLAY_REQUESTS:
		case IComposerClient::Command::SET_PRESENT_FENCE:
		case IComposerClient::Command::SET_RELEASE_FENCES:
		break;
		default:
		GTEST_FAIL() << "unexpected return command " << std::hex
		<< static_cast<int>(command);
		break;
		}

		endCommand();
		}
		}

		} // namespace tests
		} // namespace V2_1
		} // namespace composer
		} // namespace graphics
		} // namespace hardware
		} // namespace android

graphics/composer/2.1/vts/functional/TestCommandReader.h

0 → 100644

+45 −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.
		*/

		#ifndef TEST_COMMAND_READER_H
		#define TEST_COMMAND_READER_H

		#include <IComposerCommandBuffer.h>

		namespace android {
		namespace hardware {
		namespace graphics {
		namespace composer {
		namespace V2_1 {
		namespace tests {

		// A command parser that checks that no error nor unexpected commands are
		// returned.
		class TestCommandReader : public CommandReaderBase {
		public:
		// Parse all commands in the return command queue. Call GTEST_FAIL() for
		// unexpected errors or commands.
		void parse();
		};

		} // namespace tests
		} // namespace V2_1
		} // namespace composer
		} // namespace graphics
		} // namespace hardware
		} // namespace android

		#endif // TEST_COMMAND_READER_H