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, "de_debug", "DE_DEBUG", isDebug ? "1" : "not defined")); 191 addChild(new BuildEnumCase (m_testCtx, "de_os", "DE_OS", DE_OS, getOsName)); 192 addChild(new BuildEnumCase (m_testCtx, "de_cpu", "DE_CPU", DE_CPU, getCpuName)); 193 addChild(new BuildEnumCase (m_testCtx, "de_compiler", "DE_COMPILER", DE_COMPILER, getCompilerName)); 194 addChild(new BuildInfoStringCase (m_testCtx, "de_ptr_size", "DE_PTR_SIZE", de::toString(DE_PTR_SIZE).c_str())); 195 addChild(new BuildEnumCase (m_testCtx, "de_endianness", "DE_ENDIANNESS", DE_ENDIANNESS, getEndiannessName)); 196 addChild(new EndiannessConsistencyCase (m_testCtx, "de_endianness_consitent", "DE_ENDIANNESS")); 197} 198 199} // dit 200