blob: 480d84a2ba2a5be73c73085176e4fc54111169e3 [file] [log] [blame]
/*-------------------------------------------------------------------------
* drawElements Internal Test Module
* ---------------------------------
*
* 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 Build information tests.
*//*--------------------------------------------------------------------*/
#include "ditBuildInfoTests.hpp"
#include "tcuTestLog.hpp"
#include "deStringUtil.hpp"
using tcu::TestLog;
namespace dit
{
static const char* getOsName (int os)
{
switch (os)
{
case DE_OS_VANILLA: return "DE_OS_VANILLA";
case DE_OS_WIN32: return "DE_OS_WIN32";
case DE_OS_UNIX: return "DE_OS_UNIX";
case DE_OS_WINCE: return "DE_OS_WINCE";
case DE_OS_OSX: return "DE_OS_OSX";
case DE_OS_ANDROID: return "DE_OS_ANDROID";
case DE_OS_SYMBIAN: return "DE_OS_SYMBIAN";
case DE_OS_IOS: return "DE_OS_IOS";
default:
return DE_NULL;
}
}
static const char* getCompilerName (int compiler)
{
switch (compiler)
{
case DE_COMPILER_VANILLA: return "DE_COMPILER_VANILLA";
case DE_COMPILER_MSC: return "DE_COMPILER_MSC";
case DE_COMPILER_GCC: return "DE_COMPILER_GCC";
case DE_COMPILER_CLANG: return "DE_COMPILER_CLANG";
default:
return DE_NULL;
}
}
static const char* getCpuName (int cpu)
{
switch (cpu)
{
case DE_CPU_VANILLA: return "DE_CPU_VANILLA";
case DE_CPU_ARM: return "DE_CPU_ARM";
case DE_CPU_X86: return "DE_CPU_X86";
case DE_CPU_X86_64: return "DE_CPU_X86_64";
case DE_CPU_ARM_64: return "DE_CPU_ARM_64";
case DE_CPU_MIPS: return "DE_CPU_MIPS";
case DE_CPU_MIPS_64: return "DE_CPU_MIPS_64";
default:
return DE_NULL;
}
}
static const char* getEndiannessName (int endianness)
{
switch (endianness)
{
case DE_BIG_ENDIAN: return "DE_BIG_ENDIAN";
case DE_LITTLE_ENDIAN: return "DE_LITTLE_ENDIAN";
default:
return DE_NULL;
}
}
class BuildInfoStringCase : public tcu::TestCase
{
public:
BuildInfoStringCase (tcu::TestContext& testCtx, const char* name, const char* valueName, const char* value)
: tcu::TestCase (testCtx, name, valueName)
, m_valueName (valueName)
, m_value (value)
{
}
IterateResult iterate (void)
{
m_testCtx.getLog() << TestLog::Message << m_valueName << " = " << m_value << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
std::string m_valueName;
std::string m_value;
};
class BuildEnumCase : public tcu::TestCase
{
public:
typedef const char* (*GetStringFunc) (int value);
BuildEnumCase (tcu::TestContext& testCtx, const char* name, const char* varName, int value, GetStringFunc getString)
: tcu::TestCase (testCtx, name, varName)
, m_varName (varName)
, m_value (value)
, m_getString (getString)
{
}
IterateResult iterate (void)
{
const char* valueName = m_getString(m_value);
const bool isOk = valueName != DE_NULL;
std::string logValue = valueName ? std::string(valueName) : de::toString(m_value);
m_testCtx.getLog() << TestLog::Message << m_varName << " = " << logValue << TestLog::EndMessage;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "No enum name found");
return STOP;
}
private:
std::string m_varName;
int m_value;
GetStringFunc m_getString;
};
class EndiannessConsistencyCase : public tcu::TestCase
{
public:
EndiannessConsistencyCase (tcu::TestContext& context, const char* name, const char* description)
: tcu::TestCase(context, name, description)
{
}
IterateResult iterate (void)
{
const deUint16 multiByte = (deUint16)0x0102;
#if DE_ENDIANNESS == DE_BIG_ENDIAN
const bool isOk = *((const deUint8*)&multiByte) == (deUint8)0x01;
#elif DE_ENDIANNESS == DE_LITTLE_ENDIAN
const bool isOk = *((const deUint8*)&multiByte) == (deUint8)0x02;
#endif
m_testCtx.getLog()
<< TestLog::Message
<< "Verifying DE_ENDIANNESS matches actual behavior"
<< TestLog::EndMessage;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "Configured endianness inconsistent");
return STOP;
}
};
BuildInfoTests::BuildInfoTests (tcu::TestContext& testCtx)
: tcu::TestCaseGroup(testCtx, "build_info", "Build Info Tests")
{
}
BuildInfoTests::~BuildInfoTests (void)
{
}
void BuildInfoTests::init (void)
{
#if defined(DE_DEBUG)
const bool isDebug = true;
#else
const bool isDebug = false;
#endif
addChild(new BuildInfoStringCase (m_testCtx, "de_debug", "DE_DEBUG", isDebug ? "1" : "not defined"));
addChild(new BuildEnumCase (m_testCtx, "de_os", "DE_OS", DE_OS, getOsName));
addChild(new BuildEnumCase (m_testCtx, "de_cpu", "DE_CPU", DE_CPU, getCpuName));
addChild(new BuildEnumCase (m_testCtx, "de_compiler", "DE_COMPILER", DE_COMPILER, getCompilerName));
addChild(new BuildInfoStringCase (m_testCtx, "de_ptr_size", "DE_PTR_SIZE", de::toString(DE_PTR_SIZE).c_str()));
addChild(new BuildEnumCase (m_testCtx, "de_endianness", "DE_ENDIANNESS", DE_ENDIANNESS, getEndiannessName));
addChild(new EndiannessConsistencyCase (m_testCtx, "de_endianness_consitent", "DE_ENDIANNESS"));
}
} // dit