1#ifndef _XETESTCASERESULT_HPP 2#define _XETESTCASERESULT_HPP 3/*------------------------------------------------------------------------- 4 * drawElements Quality Program Test Executor 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 Test case result models. 24 *//*--------------------------------------------------------------------*/ 25 26#include "xeDefs.hpp" 27#include "xeTestCase.hpp" 28 29#include <string> 30#include <vector> 31#include <ostream> 32 33namespace xe 34{ 35 36enum TestStatusCode 37{ 38 TESTSTATUSCODE_PASS, //!< Test case passed. 39 TESTSTATUSCODE_FAIL, //!< Test case failed (not passed). 40 TESTSTATUSCODE_QUALITY_WARNING, //!< Result within specification, but suspicious quality wise 41 TESTSTATUSCODE_COMPATIBILITY_WARNING, //!< Result within specification, but likely to cause fragmentation 42 TESTSTATUSCODE_PENDING, //!< Not yet started. 43 TESTSTATUSCODE_RUNNING, //!< Currently running (not stored in database). 44 TESTSTATUSCODE_NOT_SUPPORTED, //!< Some feature was not supported in the implementation. 45 TESTSTATUSCODE_RESOURCE_ERROR, //!< A resource error has occurred. 46 TESTSTATUSCODE_INTERNAL_ERROR, //!< An internal error has occurred. 47 TESTSTATUSCODE_CANCELED, //!< User canceled the execution 48 TESTSTATUSCODE_TIMEOUT, //!< Test was killed because of watch dog timeout. 49 TESTSTATUSCODE_CRASH, //!< Test executable crashed before finishing the test. 50 TESTSTATUSCODE_DISABLED, //!< Test case disabled (for current target) 51 TESTSTATUSCODE_TERMINATED, //!< Terminated for other reason. 52 53 TESTSTATUSCODE_LAST 54}; 55 56const char* getTestStatusCodeName (TestStatusCode statusCode); 57 58namespace ri 59{ 60 61class Item; 62class Result; 63class Text; 64class Number; 65class Image; 66class ImageSet; 67class VertexShader; 68class FragmentShader; 69class ShaderProgram; 70class ShaderSource; 71class InfoLog; 72class EglConfig; 73class EglConfigSet; 74class Section; 75class KernelSource; 76class CompileInfo; 77class SampleList; 78class SampleInfo; 79class ValueInfo; 80class Sample; 81class SampleValue; 82 83// \todo [2014-02-28 pyry] Make List<T> for items that have only specific subitems. 84 85class List 86{ 87public: 88 List (void); 89 ~List (void); 90 91 int getNumItems (void) const { return (int)m_items.size(); } 92 const Item& getItem (int ndx) const { return *m_items[ndx]; } 93 Item& getItem (int ndx) { return *m_items[ndx]; } 94 95 template <typename T> 96 T* allocItem (void); 97 98private: 99 std::vector<Item*> m_items; 100}; 101 102template <typename T> 103T* List::allocItem (void) 104{ 105 m_items.reserve(m_items.size()+1); 106 T* item = new T(); 107 m_items.push_back(static_cast<ri::Item*>(item)); 108 return item; 109} 110 111} // ri 112 113class TestCaseResultHeader 114{ 115public: 116 TestCaseResultHeader (void) : caseType(TESTCASETYPE_LAST), statusCode(TESTSTATUSCODE_LAST) {} 117 118 std::string casePath; //!< Full test case path. 119 TestCaseType caseType; //!< Test case type. 120 TestStatusCode statusCode; //!< Test status code. 121 std::string statusDetails; //!< Status description. 122}; 123 124class TestCaseResult : public TestCaseResultHeader 125{ 126public: 127 ri::List resultItems; //!< Test log items. 128}; 129 130// Result items. 131namespace ri 132{ 133 134// Result item type. 135enum Type 136{ 137 TYPE_RESULT = 0, 138 TYPE_TEXT, 139 TYPE_NUMBER, 140 TYPE_IMAGE, 141 TYPE_IMAGESET, 142 TYPE_SHADER, 143 TYPE_SHADERPROGRAM, 144 TYPE_SHADERSOURCE, 145 TYPE_INFOLOG, 146 TYPE_EGLCONFIG, 147 TYPE_EGLCONFIGSET, 148 TYPE_SECTION, 149 TYPE_KERNELSOURCE, 150 TYPE_COMPILEINFO, 151 TYPE_SAMPLELIST, 152 TYPE_SAMPLEINFO, 153 TYPE_VALUEINFO, 154 TYPE_SAMPLE, 155 TYPE_SAMPLEVALUE, 156 157 TYPE_LAST 158}; 159 160class NumericValue 161{ 162public: 163 enum Type 164 { 165 TYPE_EMPTY = 0, 166 TYPE_INT64, 167 TYPE_FLOAT64, 168 169 TYPE_LAST 170 }; 171 172 NumericValue (void) : m_type(TYPE_EMPTY) {} 173 NumericValue (deInt64 value) : m_type(TYPE_INT64) { m_value.int64 = value; } 174 NumericValue (double value) : m_type(TYPE_FLOAT64) { m_value.float64 = value; } 175 176 Type getType (void) const { return m_type; } 177 deInt64 getInt64 (void) const { DE_ASSERT(getType() == TYPE_INT64); return m_value.int64; } 178 double getFloat64 (void) const { DE_ASSERT(getType() == TYPE_FLOAT64); return m_value.float64; } 179 180private: 181 Type m_type; 182 union 183 { 184 deInt64 int64; 185 double float64; 186 } m_value; 187}; 188 189std::ostream& operator<< (std::ostream& str, const NumericValue& value); 190 191class Item 192{ 193public: 194 195 virtual ~Item (void) {} 196 197 Type getType (void) const { return m_type; } 198 199protected: 200 Item (Type type) : m_type(type) {} 201 202private: 203 Item (const Item& other); 204 Item& operator= (const Item& other); 205 206 Type m_type; 207}; 208 209class Result : public Item 210{ 211public: 212 Result (void) : Item(TYPE_RESULT), statusCode(TESTSTATUSCODE_LAST) {} 213 ~Result (void) {} 214 215 TestStatusCode statusCode; 216 std::string details; 217}; 218 219class Text : public Item 220{ 221public: 222 Text (void) : Item(TYPE_TEXT) {} 223 ~Text (void) {} 224 225 std::string text; 226}; 227 228class Number : public Item 229{ 230public: 231 Number (void) : Item(TYPE_NUMBER) {} 232 ~Number (void) {} 233 234 std::string name; 235 std::string description; 236 std::string unit; 237 std::string tag; 238 NumericValue value; 239}; 240 241class Image : public Item 242{ 243public: 244 enum Format 245 { 246 FORMAT_RGB888, 247 FORMAT_RGBA8888, 248 249 FORMAT_LAST 250 }; 251 252 enum Compression 253 { 254 COMPRESSION_NONE = 0, 255 COMPRESSION_PNG, 256 257 COMPRESSION_LAST 258 }; 259 260 Image (void) : Item(TYPE_IMAGE), width(0), height(0), format(FORMAT_LAST), compression(COMPRESSION_LAST) {} 261 ~Image (void) {} 262 263 std::string name; 264 std::string description; 265 int width; 266 int height; 267 Format format; 268 Compression compression; 269 std::vector<deUint8> data; 270}; 271 272class ImageSet : public Item 273{ 274public: 275 ImageSet (void) : Item(TYPE_IMAGESET) {} 276 ~ImageSet (void) {} 277 278 std::string name; 279 std::string description; 280 List images; 281}; 282 283class ShaderSource : public Item 284{ 285public: 286 ShaderSource (void) : Item(TYPE_SHADERSOURCE) {} 287 ~ShaderSource (void) {} 288 289 std::string source; 290}; 291 292class InfoLog : public Item 293{ 294public: 295 InfoLog (void) : Item(TYPE_INFOLOG) {} 296 ~InfoLog (void) {} 297 298 std::string log; 299}; 300 301class Shader : public Item 302{ 303public: 304 enum ShaderType 305 { 306 SHADERTYPE_VERTEX = 0, 307 SHADERTYPE_FRAGMENT, 308 SHADERTYPE_GEOMETRY, 309 SHADERTYPE_TESS_CONTROL, 310 SHADERTYPE_TESS_EVALUATION, 311 SHADERTYPE_COMPUTE, 312 313 SHADERTYPE_LAST 314 }; 315 316 Shader (void) : Item(TYPE_SHADER), shaderType(SHADERTYPE_LAST), compileStatus(false) {} 317 ~Shader (void) {} 318 319 ShaderType shaderType; 320 bool compileStatus; 321 ShaderSource source; 322 InfoLog infoLog; 323}; 324 325class ShaderProgram : public Item 326{ 327public: 328 ShaderProgram (void) : Item(TYPE_SHADERPROGRAM), linkStatus(false) {} 329 ~ShaderProgram (void) {} 330 331 List shaders; 332 bool linkStatus; 333 InfoLog linkInfoLog; 334}; 335 336class EglConfig : public Item 337{ 338public: 339 EglConfig (void); 340 ~EglConfig (void) {} 341 342 int bufferSize; 343 int redSize; 344 int greenSize; 345 int blueSize; 346 int luminanceSize; 347 int alphaSize; 348 int alphaMaskSize; 349 bool bindToTextureRGB; 350 bool bindToTextureRGBA; 351 std::string colorBufferType; 352 std::string configCaveat; 353 int configID; 354 std::string conformant; 355 int depthSize; 356 int level; 357 int maxPBufferWidth; 358 int maxPBufferHeight; 359 int maxPBufferPixels; 360 int maxSwapInterval; 361 int minSwapInterval; 362 bool nativeRenderable; 363 std::string renderableType; 364 int sampleBuffers; 365 int samples; 366 int stencilSize; 367 std::string surfaceTypes; 368 std::string transparentType; 369 int transparentRedValue; 370 int transparentGreenValue; 371 int transparentBlueValue; 372}; 373 374inline EglConfig::EglConfig (void) 375 : Item (TYPE_EGLCONFIG) 376 , bufferSize (0) 377 , redSize (0) 378 , greenSize (0) 379 , blueSize (0) 380 , luminanceSize (0) 381 , alphaSize (0) 382 , alphaMaskSize (0) 383 , bindToTextureRGB (false) 384 , bindToTextureRGBA (false) 385 , configID (0) 386 , depthSize (0) 387 , level (0) 388 , maxPBufferWidth (0) 389 , maxPBufferHeight (0) 390 , maxPBufferPixels (0) 391 , maxSwapInterval (0) 392 , minSwapInterval (0) 393 , nativeRenderable (false) 394 , sampleBuffers (0) 395 , samples (0) 396 , stencilSize (0) 397 , transparentRedValue (0) 398 , transparentGreenValue (0) 399 , transparentBlueValue (0) 400{ 401} 402 403class EglConfigSet : public Item 404{ 405public: 406 EglConfigSet (void) : Item(TYPE_EGLCONFIGSET) {} 407 ~EglConfigSet (void) {} 408 409 std::string name; 410 std::string description; 411 List configs; 412}; 413 414class Section : public Item 415{ 416public: 417 Section (void) : Item(TYPE_SECTION) {} 418 ~Section (void) {} 419 420 std::string name; 421 std::string description; 422 List items; 423}; 424 425class KernelSource : public Item 426{ 427public: 428 KernelSource (void) : Item(TYPE_KERNELSOURCE) {} 429 ~KernelSource (void) {} 430 431 std::string source; 432}; 433 434class CompileInfo : public Item 435{ 436public: 437 CompileInfo (void) : Item(TYPE_COMPILEINFO), compileStatus(false) {} 438 ~CompileInfo (void) {} 439 440 std::string name; 441 std::string description; 442 bool compileStatus; 443 InfoLog infoLog; 444}; 445 446class ValueInfo : public Item 447{ 448public: 449 enum ValueTag 450 { 451 VALUETAG_PREDICTOR, 452 VALUETAG_RESPONSE, 453 454 VALUETAG_LAST 455 }; 456 457 ValueInfo (void) : Item(TYPE_VALUEINFO), tag(VALUETAG_LAST) {} 458 ~ValueInfo (void) {} 459 460 std::string name; 461 std::string description; 462 std::string unit; 463 ValueTag tag; 464}; 465 466class SampleInfo : public Item 467{ 468public: 469 SampleInfo (void) : Item(TYPE_SAMPLEINFO) {} 470 ~SampleInfo (void) {} 471 472 List valueInfos; 473}; 474 475class SampleValue : public Item 476{ 477public: 478 SampleValue (void) : Item(TYPE_SAMPLEVALUE) {} 479 ~SampleValue (void) {} 480 481 NumericValue value; 482}; 483 484class Sample : public Item 485{ 486public: 487 Sample (void) : Item(TYPE_SAMPLE) {} 488 ~Sample (void) {} 489 490 List values; 491}; 492 493class SampleList : public Item 494{ 495public: 496 SampleList (void) : Item(TYPE_SAMPLELIST) {} 497 ~SampleList (void) {} 498 499 std::string name; 500 std::string description; 501 SampleInfo sampleInfo; 502 List samples; 503}; 504 505} // ri 506} // xe 507 508#endif // _XETESTCASERESULT_HPP 509