1/*-------------------------------------------------------------------------
2 * drawElements Internal Test Module
3 * ---------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Build information tests.
22 *//*--------------------------------------------------------------------*/
23
24#include "ditBuildInfoTests.hpp"
25#include "tcuTestLog.hpp"
26#include "deStringUtil.hpp"
27
28using tcu::TestLog;
29
30namespace dit
31{
32
33static const char* getOsName (int os)
34{
35	switch (os)
36	{
37		case DE_OS_VANILLA:		return "DE_OS_VANILLA";
38		case DE_OS_WIN32:		return "DE_OS_WIN32";
39		case DE_OS_UNIX:		return "DE_OS_UNIX";
40		case DE_OS_WINCE:		return "DE_OS_WINCE";
41		case DE_OS_OSX:			return "DE_OS_OSX";
42		case DE_OS_ANDROID:		return "DE_OS_ANDROID";
43		case DE_OS_SYMBIAN:		return "DE_OS_SYMBIAN";
44		case DE_OS_IOS:			return "DE_OS_IOS";
45		default:
46			return DE_NULL;
47	}
48}
49
50static const char* getCompilerName (int compiler)
51{
52	switch (compiler)
53	{
54		case DE_COMPILER_VANILLA:	return "DE_COMPILER_VANILLA";
55		case DE_COMPILER_MSC:		return "DE_COMPILER_MSC";
56		case DE_COMPILER_GCC:		return "DE_COMPILER_GCC";
57		case DE_COMPILER_CLANG:		return "DE_COMPILER_CLANG";
58		default:
59			return DE_NULL;
60	}
61}
62
63static const char* getCpuName (int cpu)
64{
65	switch (cpu)
66	{
67		case DE_CPU_VANILLA:	return "DE_CPU_VANILLA";
68		case DE_CPU_ARM:		return "DE_CPU_ARM";
69		case DE_CPU_X86:		return "DE_CPU_X86";
70		case DE_CPU_X86_64:		return "DE_CPU_X86_64";
71		case DE_CPU_ARM_64:		return "DE_CPU_ARM_64";
72		case DE_CPU_MIPS:		return "DE_CPU_MIPS";
73		case DE_CPU_MIPS_64:	return "DE_CPU_MIPS_64";
74		default:
75			return DE_NULL;
76	}
77}
78
79static const char* getEndiannessName (int endianness)
80{
81	switch (endianness)
82	{
83		case DE_BIG_ENDIAN:		return "DE_BIG_ENDIAN";
84		case DE_LITTLE_ENDIAN:	return "DE_LITTLE_ENDIAN";
85		default:
86			return DE_NULL;
87	}
88}
89
90class BuildInfoStringCase : public tcu::TestCase
91{
92public:
93	BuildInfoStringCase (tcu::TestContext& testCtx, const char* name, const char* valueName, const char* value)
94		: tcu::TestCase	(testCtx, name, valueName)
95		, m_valueName	(valueName)
96		, m_value		(value)
97	{
98	}
99
100	IterateResult iterate (void)
101	{
102		m_testCtx.getLog() << TestLog::Message << m_valueName << " = " << m_value << TestLog::EndMessage;
103		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
104		return STOP;
105	}
106
107private:
108	std::string	m_valueName;
109	std::string	m_value;
110};
111
112class BuildEnumCase : public tcu::TestCase
113{
114public:
115	typedef const char* (*GetStringFunc) (int value);
116
117	BuildEnumCase (tcu::TestContext& testCtx, const char* name, const char* varName, int value, GetStringFunc getString)
118		: tcu::TestCase	(testCtx, name, varName)
119		, m_varName		(varName)
120		, m_value		(value)
121		, m_getString	(getString)
122	{
123	}
124
125	IterateResult iterate (void)
126	{
127		const char*	valueName	= m_getString(m_value);
128		const bool	isOk		= valueName != DE_NULL;
129		std::string	logValue	= valueName ? std::string(valueName) : de::toString(m_value);
130
131		m_testCtx.getLog() << TestLog::Message << m_varName << " = " << logValue << TestLog::EndMessage;
132
133		m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS	: QP_TEST_RESULT_FAIL,
134								isOk ? "Pass"				: "No enum name found");
135		return STOP;
136	}
137
138private:
139	std::string		m_varName;
140	int				m_value;
141	GetStringFunc	m_getString;
142};
143
144class EndiannessConsistencyCase : public tcu::TestCase
145{
146public:
147	EndiannessConsistencyCase (tcu::TestContext& context, const char* name, const char* description)
148		: tcu::TestCase(context, name, description)
149	{
150	}
151
152	IterateResult iterate (void)
153	{
154		const deUint16	multiByte	= (deUint16)0x0102;
155
156#if DE_ENDIANNESS == DE_BIG_ENDIAN
157		const bool		isOk		= *((const deUint8*)&multiByte) == (deUint8)0x01;
158#elif DE_ENDIANNESS == DE_LITTLE_ENDIAN
159		const bool		isOk		= *((const deUint8*)&multiByte) == (deUint8)0x02;
160#endif
161
162		m_testCtx.getLog()
163			<< TestLog::Message
164			<< "Verifying DE_ENDIANNESS matches actual behavior"
165			<< TestLog::EndMessage;
166
167		m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS	: QP_TEST_RESULT_FAIL,
168								isOk ? "Pass"				: "Configured endianness inconsistent");
169		return STOP;
170	}
171};
172
173BuildInfoTests::BuildInfoTests (tcu::TestContext& testCtx)
174	: tcu::TestCaseGroup(testCtx, "build_info", "Build Info Tests")
175{
176}
177
178BuildInfoTests::~BuildInfoTests (void)
179{
180}
181
182void BuildInfoTests::init (void)
183{
184#if defined(DE_DEBUG)
185	const bool isDebug = true;
186#else
187	const bool isDebug = false;
188#endif
189
190	addChild(new BuildInfoStringCase		(m_testCtx, "date",						"__DATE__",			__DATE__));
191	addChild(new BuildInfoStringCase		(m_testCtx, "time",						"__TIME__",			__TIME__));
192	addChild(new BuildInfoStringCase		(m_testCtx, "de_debug",					"DE_DEBUG",			isDebug ? "1" : "not defined"));
193	addChild(new BuildEnumCase				(m_testCtx, "de_os",					"DE_OS",			DE_OS,									getOsName));
194	addChild(new BuildEnumCase				(m_testCtx, "de_cpu",					"DE_CPU",			DE_CPU,									getCpuName));
195	addChild(new BuildEnumCase				(m_testCtx, "de_compiler",				"DE_COMPILER",		DE_COMPILER,							getCompilerName));
196	addChild(new BuildInfoStringCase		(m_testCtx, "de_ptr_size",				"DE_PTR_SIZE",		de::toString(DE_PTR_SIZE).c_str()));
197	addChild(new BuildEnumCase				(m_testCtx, "de_endianness",			"DE_ENDIANNESS",	DE_ENDIANNESS,							getEndiannessName));
198	addChild(new EndiannessConsistencyCase	(m_testCtx, "de_endianness_consitent", 	"DE_ENDIANNESS"));
199}
200
201} // dit
202