executor/xeTestCase.hpp

#ifndef _XETESTCASE_HPP
#define _XETESTCASE_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program Test Executor
 * ------------------------------------------
 *
 * Copyright 2014 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.
 *
 *//*!
 * \file
 * \brief Test case.
 *//*--------------------------------------------------------------------*/

#include "xeDefs.hpp"

#include <string>
#include <vector>
#include <set>
#include <map>

namespace xe
{

enum TestCaseType
{
	TESTCASETYPE_SELF_VALIDATE,
	TESTCASETYPE_CAPABILITY,
	TESTCASETYPE_ACCURACY,
	TESTCASETYPE_PERFORMANCE,

	TESTCASETYPE_LAST
};

const char* getTestCaseTypeName (TestCaseType caseType);

enum TestNodeType
{
	TESTNODETYPE_ROOT,
	TESTNODETYPE_GROUP,
	TESTNODETYPE_TEST_CASE,

	TESTNODETYPE_LAST
};

class TestGroup;
class TestCase;

class TestNode
{
public:
	virtual				~TestNode			(void) {}

	TestNodeType		getNodeType			(void) const { return m_nodeType;		}
	const char*			getName				(void) const { return m_name.c_str();	}
	const TestGroup*	getParent			(void) const { return m_parent;			}

	void				getFullPath			(std::string& path) const;
	std::string			getFullPath			(void) const { std::string str; getFullPath(str); return str; }

	const TestNode*		find				(const char* path) const;
	TestNode*			find				(const char* path);

protected:
						TestNode			(TestGroup* parent, TestNodeType nodeType, const char* name, const char* desc);

private:
						TestNode			(const TestNode& other);
	TestNode&			operator=			(const TestNode& other);

	TestGroup*			m_parent;
	TestNodeType		m_nodeType;
	std::string			m_name;
	std::string			m_description;
};

class TestGroup : public TestNode
{
public:
								~TestGroup			(void);

	int							getNumChildren		(void) const	{ return (int)m_children.size();	}
	TestNode*					getChild			(int ndx)		{ return m_children[ndx];			}
	const TestNode*				getChild			(int ndx) const	{ return m_children[ndx];			}

	TestNode*					findChildNode		(const char* path);
	const TestNode*				findChildNode		(const char* path) const;

	TestGroup*					createGroup			(const char* name, const char* description);
	TestCase*					createCase			(TestCaseType caseType, const char* name, const char* description);

protected:
								TestGroup			(TestGroup* parent, TestNodeType nodeType, const char* name, const char* description);

private:
	std::vector<TestNode*>		m_children;
	std::set<std::string>		m_childNames;		//!< Used for checking for duplicate test case names.

	// For adding TestCase to m_children. \todo [2012-06-15 pyry] Is the API broken perhaps?
	friend class TestNode;
};

class TestRoot : public TestGroup
{
public:
								TestRoot			(void);
};

class TestCase : public TestNode
{
public:
								~TestCase			(void);

	TestCaseType				getCaseType			(void) const { return m_caseType; }

	static TestCase*			createAsChild		(TestGroup* parent, TestCaseType caseType, const char* name, const char* description);

protected:
								TestCase			(TestGroup* parent, TestCaseType caseType, const char* name, const char* description);

private:
	TestCaseType				m_caseType;
};

// Helper class for efficiently constructing TestCase hierarchy from test case list.
class TestHierarchyBuilder
{
public:
										TestHierarchyBuilder		(TestRoot* root);
										~TestHierarchyBuilder		(void);

	TestCase*							createCase					(const char* path, TestCaseType caseType);

private:
										TestHierarchyBuilder		(const TestHierarchyBuilder& other);
	TestHierarchyBuilder&				operator=					(const TestHierarchyBuilder& other);

	TestRoot*							m_root;
	std::map<std::string, TestGroup*>	m_groupMap;
};

// Helper class for computing and iterating test sets.
class TestSet
{
public:
							TestSet			(void) {}
							~TestSet		(void) {}

	bool					empty			(void) const { return m_set.empty(); }

	void					add				(const TestNode* node);
	void					addCase			(const TestCase* testCase);
	void					addGroup		(const TestGroup* testGroup);

	void					remove			(const TestNode* node);
	void					removeCase		(const TestCase* testCase);
	void					removeGroup		(const TestGroup* testGroup);

	bool					hasNode			(const TestNode* node) const { return m_set.find(node) != m_set.end(); }

private:
	std::set<const TestNode*> m_set;
};

class ConstTestNodeIterator
{
public:
	static ConstTestNodeIterator	begin					(const TestNode* root);
	static ConstTestNodeIterator	end						(const TestNode* root);

	ConstTestNodeIterator&			operator++				(void);
	ConstTestNodeIterator			operator++				(int);

	const TestNode*					operator*				(void) const;

	bool							operator!=				(const ConstTestNodeIterator& other) const;

protected:
									ConstTestNodeIterator	(const TestNode* root);

private:
	struct GroupState
	{
		GroupState (const TestGroup* group_) : group(group_), childNdx(0) {}

		const TestGroup*	group;
		int					childNdx;

		bool operator!= (const GroupState& other) const
		{
			return group != other.group || childNdx != other.childNdx;
		}

		bool operator== (const GroupState& other) const
		{
			return group == other.group && childNdx == other.childNdx;
		}
	};

	const TestNode*					m_root;
	std::vector<GroupState>			m_iterStack;
};

// \todo [2012-06-19 pyry] Implement following iterators:
//  - TestNodeIterator
//  - ConstTestSetIterator
//  - TestSetIterator

} // xe

#endif // _XETESTCASE_HPP