• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 #ifndef _TCUTESTCASE_HPP
2 #define _TCUTESTCASE_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program Tester Core
5  * ----------------------------------------
6  *
7  * Copyright 2014 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief Base class for a test case.
24  *//*--------------------------------------------------------------------*/
25 
26 #include "tcuDefs.hpp"
27 #include "tcuTestContext.hpp"
28 
29 #include <string>
30 #include <vector>
31 
32 namespace tcu
33 {
34 
35 enum TestNodeType
36 {
37 	NODETYPE_ROOT = 0,		//!< Root for all test packages.
38 	NODETYPE_PACKAGE,		//!< Test case package -- same as group, but is omitted from XML dump.
39 	NODETYPE_GROUP,			//!< Test case container -- cannot be executed.
40 	NODETYPE_SELF_VALIDATE,	//!< Self-validating test case -- can be executed
41 	NODETYPE_PERFORMANCE,	//!< Performace test case -- can be executed
42 	NODETYPE_CAPABILITY,	//!< Capability score case -- can be executed
43 	NODETYPE_ACCURACY		//!< Accuracy test case -- can be executed
44 };
45 
46 enum TestNodeClass
47 {
48 	NODECLASS_GROUP = 0,	//!< Root or non-leaf in the test hierarchy tree
49 	NODECLASS_EXECUTABLE,	//!< Non-root leaf in the test hierarchy tree
50 
51 	NODECLASS_LAST
52 };
53 
54 enum TestRunnerType
55 {
56 	RUNNERTYPE_ANY		= 0u,
57 	RUNNERTYPE_NONE		= (1u << 0),
58 	RUNNERTYPE_AMBER	= (1u << 1)
59 };
60 
getTestNodeTypeClass(TestNodeType type)61 inline TestNodeClass getTestNodeTypeClass (TestNodeType type)
62 {
63 	switch (type)
64 	{
65 		case NODETYPE_ROOT:				return NODECLASS_GROUP;
66 		case NODETYPE_PACKAGE:			return NODECLASS_GROUP;
67 		case NODETYPE_GROUP:			return NODECLASS_GROUP;
68 		case NODETYPE_SELF_VALIDATE:	return NODECLASS_EXECUTABLE;
69 		case NODETYPE_PERFORMANCE:		return NODECLASS_EXECUTABLE;
70 		case NODETYPE_CAPABILITY:		return NODECLASS_EXECUTABLE;
71 		case NODETYPE_ACCURACY:			return NODECLASS_EXECUTABLE;
72 		default:
73 			DE_ASSERT(false);
74 			return NODECLASS_LAST;
75 	}
76 }
77 
isTestNodeTypeExecutable(TestNodeType type)78 inline bool isTestNodeTypeExecutable (TestNodeType type)
79 {
80 	return getTestNodeTypeClass(type) == NODECLASS_EXECUTABLE;
81 }
82 
isValidTestCaseNameChar(char c)83 inline bool isValidTestCaseNameChar (char c)
84 {
85 	return de::inRange(c, 'a', 'z') ||
86 		   de::inRange(c, 'A', 'Z') ||
87 		   de::inRange(c, '0', '9') ||
88 		   c == '_' || c == '-';
89 }
90 
91 /*--------------------------------------------------------------------*//*!
92  * \brief Test case hierarchy node
93  *
94  * Test node forms the backbone of the test case hierarchy. All objects
95  * in the hierarchy are derived from this class.
96  *
97  * Each test node has a type and all except the root node have name and
98  * description. Root and test group nodes have a list of children.
99  *
100  * During test execution TestExecutor iterates the hierarchy. Upon entering
101  * the node (both groups and test cases) init() is called. When exiting the
102  * node deinit() is called respectively.
103  *//*--------------------------------------------------------------------*/
104 class TestNode
105 {
106 public:
107 	enum IterateResult
108 	{
109 		STOP		= 0,
110 		CONTINUE	= 1
111 	};
112 
113 	// Methods.
114 							TestNode		(TestContext& testCtx, TestNodeType nodeType, const char* name, const char* description);
115 							TestNode		(TestContext& testCtx, TestNodeType nodeType, const char* name, const char* description, const std::vector<TestNode*>& children);
116 	virtual					~TestNode		(void);
117 
getNodeType(void) const118 	TestNodeType			getNodeType		(void) const	{ return m_nodeType;			}
getTestContext(void) const119 	TestContext&			getTestContext	(void) const	{ return m_testCtx;				}
getName(void) const120 	const char*				getName			(void) const	{ return m_name.c_str();		}
getDescription(void) const121 	const char*				getDescription	(void) const	{ return m_description.c_str(); }
122 	void					getChildren		(std::vector<TestNode*>& children);
123 	void					addChild		(TestNode* node);
124 
125 	virtual void			init			(void);
126 	virtual void			deinit			(void);
127 	virtual IterateResult	iterate			(void) = 0;
getRunnerType(void) const128 	virtual TestRunnerType	getRunnerType	(void) const	{ return RUNNERTYPE_NONE;		}
129 
130 protected:
131 	TestContext&			m_testCtx;
132 	std::string				m_name;
133 	std::string				m_description;
134 
135 private:
136 	const TestNodeType		m_nodeType;
137 	std::vector<TestNode*>	m_children;
138 };
139 
140 /*--------------------------------------------------------------------*//*!
141  * \brief Test case group node
142  *
143  * Test case group implementations must inherit this class. To save resources
144  * during test execution the group must delay creation of any child groups
145  * until init() is called.
146  *
147  * Default deinit() for test group will destroy all child nodes.
148  *//*--------------------------------------------------------------------*/
149 class TestCaseGroup : public TestNode
150 {
151 public:
152 							TestCaseGroup	(TestContext& testCtx, const char* name, const char* description);
153 							TestCaseGroup	(TestContext& testCtx, const char* name, const char* description, const std::vector<TestNode*>& children);
154 	virtual					~TestCaseGroup	(void);
155 
156 	virtual IterateResult	iterate			(void);
157 };
158 
159 /*--------------------------------------------------------------------*//*!
160  * \brief Test case class
161  *
162  * Test case implementations must inherit this class.
163  *
164  * Test case objects are usually constructed when TestExecutor enters parent
165  * group. Allocating any non-parameter resources, especially target API objects
166  * must be delayed to init().
167  *
168  * Upon entering the test case TestExecutor calls init(). If initialization
169  * is successful (no exception is thrown) the executor will then call iterate()
170  * until test case returns STOP. After that deinit() will be called.
171  *
172  * Before exiting the execution phase (i.e. at returning STOP from iterate())
173  * the test case must set valid status code to test context (m_testCtx).
174  *
175  * Test case can also signal error condition by throwing an exception. In
176  * that case the framework will set result code and details based on the
177  * exception.
178  *//*--------------------------------------------------------------------*/
179 class TestCase : public TestNode
180 {
181 public:
182 					TestCase			(TestContext& testCtx, const char* name, const char* description);
183 					TestCase			(TestContext& testCtx, TestNodeType nodeType, const char* name, const char* description);
184 	virtual			~TestCase			(void);
185 };
186 
187 class TestStatus
188 {
189 public:
TestStatus(qpTestResult code,const std::string & description)190 						TestStatus		(qpTestResult code, const std::string& description) : m_code(code), m_description(description) {}
191 
isComplete(void) const192 	bool				isComplete		(void) const { return m_code != QP_TEST_RESULT_LAST;			}
getCode(void) const193 	qpTestResult		getCode			(void) const { DE_ASSERT(isComplete()); return m_code;			}
getDescription(void) const194 	const std::string&	getDescription	(void) const { DE_ASSERT(isComplete()); return m_description;	}
195 
pass(const std::string & description)196 	static TestStatus	pass			(const std::string& description)	{ return TestStatus(QP_TEST_RESULT_PASS,	description);	}
fail(const std::string & description)197 	static TestStatus	fail			(const std::string& description)	{ return TestStatus(QP_TEST_RESULT_FAIL,	description);	}
incomplete(void)198 	static TestStatus	incomplete		(void)								{ return TestStatus(QP_TEST_RESULT_LAST,	"");			}
199 
200 private:
201 	qpTestResult		m_code;
202 	std::string			m_description;
203 } DE_WARN_UNUSED_TYPE;
204 
205 } // tcu
206 
207 #endif // _TCUTESTCASE_HPP
208