framework/qphelper/qpTestLog.c

   1 /*-------------------------------------------------------------------------
   2  * drawElements TestLog Library
   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 Test case result logging
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "qpTestLog.h"
  25 #include "qpXmlWriter.h"
  26 #include "qpInfo.h"
  27 #include "qpDebugOut.h"
  28
  29 #include "deMemory.h"
  30 #include "deInt32.h"
  31 #include "deString.h"
  32
  33 #include "deMutex.h"
  34
  35 #if defined(QP_SUPPORT_PNG)
  36 #       include <png.h>
  37 #endif
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <stdarg.h>
  42
  43 #if (DE_OS == DE_OS_WIN32)
  44 #       include <windows.h>
  45 #       include <io.h>
  46 #endif
  47
  48 #if defined(DE_DEBUG)
  49
  50 /* Utils for verifying container (Section, ImageSet, EglConfigSet) usage in debug builds. */
  51
  52 typedef enum ContainerType_e
  53 {
  54         CONTAINERTYPE_SECTION = 0,
  55         CONTAINERTYPE_IMAGESET,
  56         CONTAINERTYPE_EGLCONFIGSET,
  57         CONTAINERTYPE_SHADERPROGRAM,
  58         CONTAINERTYPE_SAMPLELIST,
  59         CONTAINERTYPE_SAMPLEINFO,
  60         CONTAINERTYPE_SAMPLE,
  61
  62         CONTAINERTYPE_LAST
  63 } ContainerType;
  64
  65 DE_INLINE deBool childContainersOk (ContainerType type)
  66 {
  67         return type == CONTAINERTYPE_SECTION || type == CONTAINERTYPE_SAMPLELIST;
  68 }
  69
  70 enum
  71 {
  72         MAX_CONTAINER_STACK_DEPTH               = 32
  73 };
  74
  75 typedef struct ContainerStack_s
  76 {
  77         int                             numElements;
  78         ContainerType   elements[MAX_CONTAINER_STACK_DEPTH];
  79 } ContainerStack;
  80
  81 DE_INLINE void ContainerStack_reset (ContainerStack* stack)
  82 {
  83         deMemset(stack, 0, sizeof(ContainerStack));
  84 }
  85
  86 DE_INLINE deBool ContainerStack_isEmpty (const ContainerStack* stack)
  87 {
  88         return stack->numElements == 0;
  89 }
  90
  91 DE_INLINE deBool ContainerStack_push (ContainerStack* stack, ContainerType type)
  92 {
  93         if (stack->numElements == MAX_CONTAINER_STACK_DEPTH)
  94                 return DE_FALSE;
  95
  96         if (stack->numElements > 0 && !childContainersOk(stack->elements[stack->numElements-1]))
  97                 return DE_FALSE;
  98
  99         stack->elements[stack->numElements]  = type;
 100         stack->numElements                                      += 1;
 101
 102         return DE_TRUE;
 103 }
 104
 105 DE_INLINE ContainerType ContainerStack_pop (ContainerStack* stack)
 106 {
 107         DE_ASSERT(stack->numElements > 0);
 108         stack->numElements -= 1;
 109         return stack->elements[stack->numElements];
 110 }
 111
 112 DE_INLINE ContainerType ContainerStack_getTop (const ContainerStack* stack)
 113 {
 114         if (stack->numElements > 0)
 115                 return stack->elements[stack->numElements-1];
 116         else
 117                 return CONTAINERTYPE_LAST;
 118 }
 119
 120 #endif
 121
 122 /* qpTestLog instance */
 123 struct qpTestLog_s
 124 {
 125         deUint32                                flags;                          /*!< Logging flags.                                             */
 126
 127         deMutex                                 lock;                           /*!< Lock for mutable state below.              */
 128
 129         /* State protected by lock. */
 130         FILE*                                   outputFile;
 131         qpXmlWriter*                    writer;
 132         deBool                                  isSessionOpen;
 133         deBool                                  isCaseOpen;
 134
 135 #if defined(DE_DEBUG)
 136         ContainerStack                  containerStack;         /*!< For container usage verification.  */
 137 #endif
 138 };
 139
 140 /* Maps integer to string. */
 141 typedef struct qpKeyStringMap_s
 142 {
 143         int             key;
 144         char*   string;
 145 } qpKeyStringMap;
 146
 147 static const char* LOG_FORMAT_VERSION = "0.3.4";
 148
 149 /* Mapping enum to above strings... */
 150 static const qpKeyStringMap s_qpTestTypeMap[] =
 151 {
 152         { QP_TEST_CASE_TYPE_SELF_VALIDATE,              "SelfValidate"  },
 153         { QP_TEST_CASE_TYPE_PERFORMANCE,                "Performance"   },
 154         { QP_TEST_CASE_TYPE_CAPABILITY,                 "Capability"    },
 155         { QP_TEST_CASE_TYPE_ACCURACY,                   "Accuracy"              },
 156
 157         { QP_TEST_CASE_TYPE_LAST,                               DE_NULL                 }
 158 };
 159
 160 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpTestTypeMap) == QP_TEST_CASE_TYPE_LAST + 1);
 161
 162 static const qpKeyStringMap s_qpTestResultMap[] =
 163 {
 164         { QP_TEST_RESULT_PASS,                                          "Pass"                                  },
 165         { QP_TEST_RESULT_FAIL,                                          "Fail"                                  },
 166         { QP_TEST_RESULT_QUALITY_WARNING,                       "QualityWarning"                },
 167         { QP_TEST_RESULT_COMPATIBILITY_WARNING,         "CompatibilityWarning"  },
 168         { QP_TEST_RESULT_PENDING,                                       "Pending"                               },      /* should not be needed here */
 169         { QP_TEST_RESULT_NOT_SUPPORTED,                         "NotSupported"                  },
 170         { QP_TEST_RESULT_RESOURCE_ERROR,                        "ResourceError"                 },
 171         { QP_TEST_RESULT_INTERNAL_ERROR,                        "InternalError"                 },
 172         { QP_TEST_RESULT_CRASH,                                         "Crash"                                 },
 173         { QP_TEST_RESULT_TIMEOUT,                                       "Timeout"                               },
 174
 175         /* Add new values here if needed, remember to update qpTestResult enumeration. */
 176
 177         { QP_TEST_RESULT_LAST,                                          DE_NULL                                 }
 178 };
 179
 180 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpTestResultMap) == QP_TEST_RESULT_LAST + 1);
 181
 182 /* Key tag to string mapping. */
 183
 184 static const qpKeyStringMap s_qpTagMap[] =
 185 {
 186         { QP_KEY_TAG_NONE,                      DE_NULL                 },
 187         { QP_KEY_TAG_PERFORMANCE,       "Performance"   },
 188         { QP_KEY_TAG_QUALITY,           "Quality"               },
 189         { QP_KEY_TAG_PRECISION,         "Precision"             },
 190         { QP_KEY_TAG_TIME,                      "Time"                  },
 191
 192         { QP_KEY_TAG_LAST,                      DE_NULL                 }
 193 };
 194
 195 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpTagMap) == QP_KEY_TAG_LAST + 1);
 196
 197 /* Sample value tag to string mapping. */
 198
 199 static const qpKeyStringMap s_qpSampleValueTagMap[] =
 200 {
 201         { QP_SAMPLE_VALUE_TAG_PREDICTOR,        "Predictor"     },
 202         { QP_SAMPLE_VALUE_TAG_RESPONSE,         "Response"      },
 203
 204         { QP_SAMPLE_VALUE_TAG_LAST,                     DE_NULL         }
 205 };
 206
 207 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpSampleValueTagMap) == QP_SAMPLE_VALUE_TAG_LAST + 1);
 208
 209 /* Image compression mode to string mapping. */
 210
 211 static const qpKeyStringMap s_qpImageCompressionModeMap[] =
 212 {
 213         { QP_IMAGE_COMPRESSION_MODE_NONE,       "None"  },
 214         { QP_IMAGE_COMPRESSION_MODE_PNG,        "PNG"   },
 215
 216         { QP_IMAGE_COMPRESSION_MODE_BEST,       DE_NULL },      /* not allowed to be written! */
 217
 218         { QP_IMAGE_COMPRESSION_MODE_LAST,       DE_NULL }
 219 };
 220
 221 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpImageCompressionModeMap) == QP_IMAGE_COMPRESSION_MODE_LAST + 1);
 222
 223 /* Image format to string mapping. */
 224
 225 static const qpKeyStringMap s_qpImageFormatMap[] =
 226 {
 227         { QP_IMAGE_FORMAT_RGB888,       "RGB888"        },
 228         { QP_IMAGE_FORMAT_RGBA8888,     "RGBA8888"      },
 229
 230         { QP_IMAGE_FORMAT_LAST,         DE_NULL         }
 231 };
 232
 233 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpImageFormatMap) == QP_IMAGE_FORMAT_LAST + 1);
 234
 235 /* Shader type to string mapping. */
 236
 237 static const qpKeyStringMap s_qpShaderTypeMap[] =
 238 {
 239         { QP_SHADER_TYPE_VERTEX,                        "VertexShader"                  },
 240         { QP_SHADER_TYPE_FRAGMENT,                      "FragmentShader"                },
 241         { QP_SHADER_TYPE_GEOMETRY,                      "GeometryShader"                },
 242         { QP_SHADER_TYPE_TESS_CONTROL,          "TessControlShader"             },
 243         { QP_SHADER_TYPE_TESS_EVALUATION,       "TessEvaluationShader"  },
 244         { QP_SHADER_TYPE_COMPUTE,                       "ComputeShader"                 },
 245
 246         { QP_SHADER_TYPE_LAST,                          DE_NULL                                 }
 247 };
 248
 249 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpShaderTypeMap) == QP_SHADER_TYPE_LAST + 1);
 250
 251 static void qpTestLog_flushFile (qpTestLog* log)
 252 {
 253         DE_ASSERT(log && log->outputFile);
 254         fflush(log->outputFile);
 255 #if (DE_OS == DE_OS_WIN32) && (DE_COMPILER == DE_COMPILER_MSC)
 256         /* \todo [petri] Is this really necessary? */
 257         FlushFileBuffers((HANDLE)_get_osfhandle(_fileno(log->outputFile)));
 258 #endif
 259 }
 260
 261 #define QP_LOOKUP_STRING(KEYMAP, KEY)   qpLookupString(KEYMAP, DE_LENGTH_OF_ARRAY(KEYMAP), (int)(KEY))
 262
 263 static const char* qpLookupString (const qpKeyStringMap* keyMap, int keyMapSize, int key)
 264 {
 265         DE_ASSERT(keyMap);
 266         DE_ASSERT(deInBounds32(key, 0, keyMapSize));
 267         DE_ASSERT(keyMap[key].key == key);
 268         DE_UNREF(keyMapSize); /* for asserting only */
 269         return keyMap[key].string;
 270 }
 271
 272 DE_INLINE void int32ToString (int val, char buf[32])
 273 {
 274         deSprintf(&buf[0], 32, "%d", val);
 275 }
 276
 277 DE_INLINE void int64ToString (deInt64 val, char buf[32])
 278 {
 279         deSprintf(&buf[0], 32, "%lld", (long long int)val);
 280 }
 281
 282 DE_INLINE void floatToString (float value, char* buf, size_t bufSize)
 283 {
 284         deSprintf(buf, bufSize, "%f", value);
 285 }
 286
 287 DE_INLINE void doubleToString (double value, char* buf, size_t bufSize)
 288 {
 289         deSprintf(buf, bufSize, "%f", value);
 290 }
 291
 292 static deBool beginSession (qpTestLog* log)
 293 {
 294         DE_ASSERT(log && !log->isSessionOpen);
 295
 296         /* Write session info. */
 297         fprintf(log->outputFile, "#sessionInfo releaseName %s\n", qpGetReleaseName());
 298         fprintf(log->outputFile, "#sessionInfo releaseId 0x%08x\n", qpGetReleaseId());
 299         fprintf(log->outputFile, "#sessionInfo targetName \"%s\"\n", qpGetTargetName());
 300
 301     /* Write out #beginSession. */
 302         fprintf(log->outputFile, "#beginSession\n");
 303         qpTestLog_flushFile(log);
 304
 305         log->isSessionOpen = DE_TRUE;
 306
 307         return DE_TRUE;
 308 }
 309
 310 static deBool endSession (qpTestLog* log)
 311 {
 312         DE_ASSERT(log && log->isSessionOpen);
 313
 314     /* Make sure xml is flushed. */
 315     qpXmlWriter_flush(log->writer);
 316
 317     /* Write out #endSession. */
 318         fprintf(log->outputFile, "\n#endSession\n");
 319         qpTestLog_flushFile(log);
 320
 321         log->isSessionOpen = DE_FALSE;
 322
 323         return DE_TRUE;
 324 }
 325
 326 /*--------------------------------------------------------------------*//*!
 327  * \brief Create a file based logger instance
 328  * \param fileName Name of the file where to put logs
 329  * \return qpTestLog instance, or DE_NULL if cannot create file
 330  *//*--------------------------------------------------------------------*/
 331 qpTestLog* qpTestLog_createFileLog (const char* fileName, deUint32 flags)
 332 {
 333         qpTestLog* log = (qpTestLog*)deCalloc(sizeof(qpTestLog));
 334         if (!log)
 335                 return DE_NULL;
 336
 337         DE_ASSERT(fileName && fileName[0]); /* must have filename. */
 338
 339 #if defined(DE_DEBUG)
 340         ContainerStack_reset(&log->containerStack);
 341 #endif
 342
 343         /* Create output file. */
 344         log->outputFile = fopen(fileName, "wb");
 345         if (!log->outputFile)
 346         {
 347                 qpPrintf("ERROR: Unable to open test log output file '%s'.\n", fileName);
 348                 qpTestLog_destroy(log);
 349                 return DE_NULL;
 350         }
 351
 352         log->flags                      = flags;
 353         log->writer                     = qpXmlWriter_createFileWriter(log->outputFile, 0, !(flags & QP_TEST_LOG_NO_FLUSH));
 354         log->lock                       = deMutex_create(DE_NULL);
 355         log->isSessionOpen      = DE_FALSE;
 356         log->isCaseOpen         = DE_FALSE;
 357
 358         if (!log->writer)
 359         {
 360                 qpPrintf("ERROR: Unable to create output XML writer to file '%s'.\n", fileName);
 361                 qpTestLog_destroy(log);
 362                 return DE_NULL;
 363         }
 364
 365         if (!log->lock)
 366         {
 367                 qpPrintf("ERROR: Unable to create mutex.\n");
 368                 qpTestLog_destroy(log);
 369                 return DE_NULL;
 370         }
 371
 372         beginSession(log);
 373
 374         return log;
 375 }
 376
 377 /*--------------------------------------------------------------------*//*!
 378  * \brief Destroy a logger instance
 379  * \param a     qpTestLog instance
 380  *//*--------------------------------------------------------------------*/
 381 void qpTestLog_destroy (qpTestLog* log)
 382 {
 383         DE_ASSERT(log);
 384
 385         if (log->isSessionOpen)
 386                 endSession(log);
 387
 388         if (log->writer)
 389                 qpXmlWriter_destroy(log->writer);
 390
 391         if (log->outputFile)
 392                 fclose(log->outputFile);
 393
 394         if (log->lock)
 395                 deMutex_destroy(log->lock);
 396
 397         deFree(log);
 398 }
 399
 400 /*--------------------------------------------------------------------*//*!
 401  * \brief Log start of test case
 402  * \param log qpTestLog instance
 403  * \param testCasePath  Full test case path (as seen in Candy).
 404  * \param testCaseType  Test case type
 405  * \return true if ok, false otherwise
 406  *//*--------------------------------------------------------------------*/
 407 deBool qpTestLog_startCase (qpTestLog* log, const char* testCasePath, qpTestCaseType testCaseType)
 408 {
 409         const char*             typeStr                         = QP_LOOKUP_STRING(s_qpTestTypeMap, testCaseType);
 410         int                             numResultAttribs        = 0;
 411         qpXmlAttribute  resultAttribs[8];
 412
 413         DE_ASSERT(log && testCasePath && (testCasePath[0] != 0));
 414         deMutex_lock(log->lock);
 415
 416         DE_ASSERT(!log->isCaseOpen);
 417         DE_ASSERT(ContainerStack_isEmpty(&log->containerStack));
 418
 419         /* Flush XML and write out #beginTestCaseResult. */
 420         qpXmlWriter_flush(log->writer);
 421         fprintf(log->outputFile, "\n#beginTestCaseResult %s\n", testCasePath);
 422         if (!(log->flags & QP_TEST_LOG_NO_FLUSH))
 423                 qpTestLog_flushFile(log);
 424
 425         log->isCaseOpen = DE_TRUE;
 426
 427         /* Fill in attributes. */
 428         resultAttribs[numResultAttribs++] = qpSetStringAttrib("Version", LOG_FORMAT_VERSION);
 429         resultAttribs[numResultAttribs++] = qpSetStringAttrib("CasePath", testCasePath);
 430         resultAttribs[numResultAttribs++] = qpSetStringAttrib("CaseType", typeStr);
 431
 432         if (!qpXmlWriter_startDocument(log->writer) ||
 433                 !qpXmlWriter_startElement(log->writer, "TestCaseResult", numResultAttribs, resultAttribs))
 434         {
 435                 qpPrintf("qpTestLog_startCase(): Writing XML failed\n");
 436                 deMutex_unlock(log->lock);
 437                 return DE_FALSE;
 438         }
 439
 440         deMutex_unlock(log->lock);
 441         return DE_TRUE;
 442 }
 443
 444 /*--------------------------------------------------------------------*//*!
 445  * \brief Log end of test case
 446  * \param log qpTestLog instance
 447  * \param result Test result
 448  * \param description Description of a problem in case of error
 449  * \return true if ok, false otherwise
 450  *//*--------------------------------------------------------------------*/
 451 deBool qpTestLog_endCase (qpTestLog* log, qpTestResult result, const char* resultDetails)
 452 {
 453         const char*             statusStr               = QP_LOOKUP_STRING(s_qpTestResultMap, result);
 454         qpXmlAttribute  statusAttrib    = qpSetStringAttrib("StatusCode", statusStr);
 455
 456         DE_ASSERT(log && log->isCaseOpen);
 457         DE_ASSERT(ContainerStack_isEmpty(&log->containerStack));
 458         deMutex_lock(log->lock);
 459
 460         /* <Result StatusCode="Pass">Result details</Result>
 461          * </TestCaseResult>
 462          */
 463         if (!qpXmlWriter_startElement(log->writer, "Result", 1, &statusAttrib) ||
 464                 (resultDetails && !qpXmlWriter_writeString(log->writer, resultDetails)) ||
 465                 !qpXmlWriter_endElement(log->writer, "Result") ||
 466                 !qpXmlWriter_endElement(log->writer, "TestCaseResult") ||
 467                 !qpXmlWriter_endDocument(log->writer))          /* Close any XML elements still open */
 468         {
 469                 qpPrintf("qpTestLog_endCase(): Writing XML failed\n");
 470                 deMutex_unlock(log->lock);
 471                 return DE_FALSE;
 472         }
 473
 474         /* Flush XML and write #endTestCaseResult. */
 475         qpXmlWriter_flush(log->writer);
 476         fprintf(log->outputFile, "\n#endTestCaseResult\n");
 477         if (!(log->flags & QP_TEST_LOG_NO_FLUSH))
 478                 qpTestLog_flushFile(log);
 479
 480         log->isCaseOpen = DE_FALSE;
 481
 482         deMutex_unlock(log->lock);
 483         return DE_TRUE;
 484 }
 485
 486 /*--------------------------------------------------------------------*//*!
 487  * \brief Abrupt termination of logging.
 488  * \param log           qpTestLog instance
 489  * \param result        Result code, only Crash and Timeout are allowed.
 490  * \return true if ok, false otherwise
 491  *//*--------------------------------------------------------------------*/
 492 deBool qpTestLog_terminateCase (qpTestLog* log, qpTestResult result)
 493 {
 494         const char* resultStr = QP_LOOKUP_STRING(s_qpTestResultMap, result);
 495
 496         DE_ASSERT(log);
 497         DE_ASSERT(result == QP_TEST_RESULT_CRASH || result == QP_TEST_RESULT_TIMEOUT);
 498
 499         deMutex_lock(log->lock);
 500
 501         if (!log->isCaseOpen)
 502         {
 503                 deMutex_unlock(log->lock);
 504                 return DE_FALSE; /* Soft error. This is called from error handler. */
 505         }
 506
 507         /* Flush XML and write #terminateTestCaseResult. */
 508         qpXmlWriter_flush(log->writer);
 509         fprintf(log->outputFile, "\n#terminateTestCaseResult %s\n", resultStr);
 510         qpTestLog_flushFile(log);
 511
 512         log->isCaseOpen = DE_FALSE;
 513
 514 #if defined(DE_DEBUG)
 515         ContainerStack_reset(&log->containerStack);
 516 #endif
 517
 518         deMutex_unlock(log->lock);
 519         return DE_TRUE;
 520 }
 521
 522 static deBool qpTestLog_writeKeyValuePair (qpTestLog* log, const char* elementName, const char* name, const char* description, const char* unit, qpKeyValueTag tag, const char* text)
 523 {
 524         const char*             tagString = QP_LOOKUP_STRING(s_qpTagMap, tag);
 525         qpXmlAttribute  attribs[8];
 526         int                             numAttribs = 0;
 527
 528         DE_ASSERT(log && elementName && text);
 529         deMutex_lock(log->lock);
 530
 531         /* Fill in attributes. */
 532         if (name)                       attribs[numAttribs++] = qpSetStringAttrib("Name", name);
 533         if (description)        attribs[numAttribs++] = qpSetStringAttrib("Description", description);
 534         if (tagString)          attribs[numAttribs++] = qpSetStringAttrib("Tag", tagString);
 535         if (unit)                       attribs[numAttribs++] = qpSetStringAttrib("Unit", unit);
 536
 537         if (!qpXmlWriter_startElement(log->writer, elementName, numAttribs, attribs) ||
 538                 !qpXmlWriter_writeString(log->writer, text) ||
 539                 !qpXmlWriter_endElement(log->writer, elementName))
 540         {
 541                 qpPrintf("qpTestLog_writeKeyValuePair(): Writing XML failed\n");
 542                 deMutex_unlock(log->lock);
 543                 return DE_FALSE;
 544         }
 545
 546         deMutex_unlock(log->lock);
 547         return DE_TRUE;
 548 }
 549
 550 /*--------------------------------------------------------------------*//*!
 551  * \brief Write a message to output log
 552  * \param log           qpTestLog instance
 553  * \param format        Format string of message
 554  * \param ...           Parameters for message
 555  * \return true if ok, false otherwise
 556  *//*--------------------------------------------------------------------*/
 557 deBool qpTestLog_writeMessage (qpTestLog* log, const char* format, ...)
 558 {
 559         char    buffer[1024];
 560         va_list args;
 561
 562         /* \todo [petri] Handle buffer overflows! */
 563
 564         va_start(args, format);
 565         buffer[DE_LENGTH_OF_ARRAY(buffer) - 1] = 0;
 566         vsnprintf(buffer, sizeof(buffer), format, args);
 567         va_end(args);
 568
 569         printf("%s\n", buffer);
 570
 571         /* <Text>text</Text> */
 572         return qpTestLog_writeKeyValuePair(log, "Text", DE_NULL, DE_NULL, DE_NULL, QP_KEY_TAG_LAST, buffer);
 573 }
 574
 575 /*--------------------------------------------------------------------*//*!
 576  * \brief Write key-value-pair into log
 577  * \param log                   qpTestLog instance
 578  * \param name                  Unique identifier for entry
 579  * \param description   Human readable description
 580  * \param tag                   Optional tag
 581  * \param value                 Value of the key-value-pair
 582  * \return true if ok, false otherwise
 583  *//*--------------------------------------------------------------------*/
 584 deBool qpTestLog_writeText (qpTestLog* log, const char* name, const char* description, qpKeyValueTag tag, const char* text)
 585 {
 586         /* <Text Name="name" Description="description" Tag="tag">text</Text> */
 587         return qpTestLog_writeKeyValuePair(log, "Text", name, description, DE_NULL, tag, text);
 588 }
 589
 590 /*--------------------------------------------------------------------*//*!
 591  * \brief Write key-value-pair into log
 592  * \param log                   qpTestLog instance
 593  * \param name                  Unique identifier for entry
 594  * \param description   Human readable description
 595  * \param tag                   Optional tag
 596  * \param value                 Value of the key-value-pair
 597  * \return true if ok, false otherwise
 598  *//*--------------------------------------------------------------------*/
 599 deBool qpTestLog_writeInteger (qpTestLog* log, const char* name, const char* description, const char* unit, qpKeyValueTag tag, deInt64 value)
 600 {
 601         char tmpString[64];
 602         int64ToString(value, tmpString);
 603
 604         printf("%s = %lld %s\n", description, (signed long long)value, unit ? unit : "");
 605
 606         /* <Number Name="name" Description="description" Tag="Performance">15</Number> */
 607         return qpTestLog_writeKeyValuePair(log, "Number", name, description, unit, tag, tmpString);
 608 }
 609
 610 /*--------------------------------------------------------------------*//*!
 611  * \brief Write key-value-pair into log
 612  * \param log                   qpTestLog instance
 613  * \param name                  Unique identifier for entry
 614  * \param description   Human readable description
 615  * \param tag                   Optional tag
 616  * \param value                 Value of the key-value-pair
 617  * \return true if ok, false otherwise
 618  *//*--------------------------------------------------------------------*/
 619 deBool qpTestLog_writeFloat (qpTestLog* log, const char* name, const char* description, const char* unit, qpKeyValueTag tag, float value)
 620 {
 621         char tmpString[64];
 622         floatToString(value, tmpString, sizeof(tmpString));
 623
 624         printf("%s = %f %s\n", description, value, unit ? unit : "");
 625
 626         /* <Number Name="name" Description="description" Tag="Performance">15</Number> */
 627         return qpTestLog_writeKeyValuePair(log, "Number", name, description, unit, tag, tmpString);
 628 }
 629
 630 typedef struct Buffer_s
 631 {
 632         size_t          capacity;
 633         size_t          size;
 634         deUint8*        data;
 635 } Buffer;
 636
 637 void Buffer_init (Buffer* buffer)
 638 {
 639         buffer->capacity        = 0;
 640         buffer->size            = 0;
 641         buffer->data            = DE_NULL;
 642 }
 643
 644 void Buffer_deinit (Buffer* buffer)
 645 {
 646         deFree(buffer->data);
 647         Buffer_init(buffer);
 648 }
 649
 650 deBool Buffer_resize (Buffer* buffer, size_t newSize)
 651 {
 652         /* Grow buffer if necessary. */
 653         if (newSize > buffer->capacity)
 654         {
 655                 size_t          newCapacity     = (size_t)deAlign32(deMax32(2*(int)buffer->capacity, (int)newSize), 512);
 656                 deUint8*        newData         = (deUint8*)deMalloc(newCapacity);
 657                 if (!newData)
 658                         return DE_FALSE;
 659
 660                 memcpy(newData, buffer->data, buffer->size);
 661                 deFree(buffer->data);
 662                 buffer->data            = newData;
 663                 buffer->capacity        = newCapacity;
 664         }
 665
 666         buffer->size = newSize;
 667         return DE_TRUE;
 668 }
 669
 670 deBool Buffer_append (Buffer* buffer, const deUint8* data, size_t numBytes)
 671 {
 672         size_t offset = buffer->size;
 673
 674         if (!Buffer_resize(buffer, buffer->size + numBytes))
 675                 return DE_FALSE;
 676
 677         /* Append bytes. */
 678         memcpy(&buffer->data[offset], data, numBytes);
 679         return DE_TRUE;
 680 }
 681
 682 #if defined(QP_SUPPORT_PNG)
 683 void pngWriteData (png_structp png, png_bytep dataPtr, png_size_t numBytes)
 684 {
 685         Buffer* buffer = (Buffer*)png_get_io_ptr(png);
 686         if (!Buffer_append(buffer, (const deUint8*)dataPtr, numBytes))
 687                 png_error(png, "unable to resize PNG write buffer!");
 688 }
 689
 690 void pngFlushData (png_structp png)
 691 {
 692         DE_UNREF(png);
 693         /* nada */
 694 }
 695
 696 static deBool writeCompressedPNG (png_structp png, png_infop info, png_byte** rowPointers, int width, int height, int colorFormat)
 697 {
 698         if (setjmp(png_jmpbuf(png)) == 0)
 699         {
 700                 /* Write data. */
 701                 png_set_IHDR(png, info, (png_uint_32)width, (png_uint_32)height,
 702                         8,
 703                         colorFormat,
 704                         PNG_INTERLACE_NONE,
 705                         PNG_COMPRESSION_TYPE_BASE,
 706                         PNG_FILTER_TYPE_BASE);
 707                 png_write_info(png, info);
 708                 png_write_image(png, rowPointers);
 709                 png_write_end(png, NULL);
 710
 711                 return DE_TRUE;
 712         }
 713         else
 714                 return DE_FALSE;
 715 }
 716
 717 static deBool compressImagePNG (Buffer* buffer, qpImageFormat imageFormat, int width, int height, int rowStride, const void* data)
 718 {
 719         deBool                  compressOk              = DE_FALSE;
 720         png_structp             png                             = DE_NULL;
 721         png_infop               info                    = DE_NULL;
 722         png_byte**              rowPointers             = DE_NULL;
 723         deBool                  hasAlpha                = imageFormat == QP_IMAGE_FORMAT_RGBA8888;
 724         int                             ndx;
 725
 726         /* Handle format. */
 727         DE_ASSERT(imageFormat == QP_IMAGE_FORMAT_RGB888 || imageFormat == QP_IMAGE_FORMAT_RGBA8888);
 728
 729         /* Allocate & set row pointers. */
 730         rowPointers = (png_byte**)deMalloc((size_t)height * sizeof(png_byte*));
 731         if (!rowPointers)
 732                 return DE_FALSE;
 733
 734         for (ndx = 0; ndx < height; ndx++)
 735                 rowPointers[ndx] = (png_byte*)((const deUint8*)data + ndx*rowStride);
 736
 737         /* Initialize PNG compressor. */
 738         png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 739         info = png ? png_create_info_struct(png) : DE_NULL;
 740         if (png && info)
 741         {
 742                 /* Set our own write function. */
 743                 png_set_write_fn(png, buffer, pngWriteData, pngFlushData);
 744
 745                 compressOk = writeCompressedPNG(png, info, rowPointers, width, height,
 746                                                                                 hasAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB);
 747         }
 748
 749         /* Cleanup & return. */
 750         if (png && info)
 751         {
 752                 png_destroy_info_struct(png, &info);
 753                 png_destroy_write_struct(&png, DE_NULL);
 754         }
 755         else if (png)
 756                 png_destroy_write_struct(&png, &info);
 757
 758         deFree(rowPointers);
 759         return compressOk;
 760 }
 761 #endif /* QP_SUPPORT_PNG */
 762
 763 /*--------------------------------------------------------------------*//*!
 764  * \brief Start image set
 765  * \param log                   qpTestLog instance
 766  * \param name                  Unique identifier for the set
 767  * \param description   Human readable description
 768  * \return true if ok, false otherwise
 769  *//*--------------------------------------------------------------------*/
 770 deBool qpTestLog_startImageSet (qpTestLog* log, const char* name, const char* description)
 771 {
 772         qpXmlAttribute  attribs[4];
 773         int                             numAttribs = 0;
 774
 775         DE_ASSERT(log && name);
 776         deMutex_lock(log->lock);
 777
 778         attribs[numAttribs++] = qpSetStringAttrib("Name", name);
 779         if (description)
 780                 attribs[numAttribs++] = qpSetStringAttrib("Description", description);
 781
 782         /* <ImageSet Name="<name>"> */
 783         if (!qpXmlWriter_startElement(log->writer, "ImageSet", numAttribs, attribs))
 784         {
 785                 qpPrintf("qpTestLog_startImageSet(): Writing XML failed\n");
 786                 deMutex_unlock(log->lock);
 787                 return DE_FALSE;
 788         }
 789
 790         DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_IMAGESET));
 791
 792         deMutex_unlock(log->lock);
 793         return DE_TRUE;
 794 }
 795
 796 /*--------------------------------------------------------------------*//*!
 797  * \brief End image set
 798  * \param log                   qpTestLog instance
 799  * \return true if ok, false otherwise
 800  *//*--------------------------------------------------------------------*/
 801 deBool qpTestLog_endImageSet (qpTestLog* log)
 802 {
 803         DE_ASSERT(log);
 804         deMutex_lock(log->lock);
 805
 806         /* <ImageSet Name="<name>"> */
 807         if (!qpXmlWriter_endElement(log->writer, "ImageSet"))
 808         {
 809                 qpPrintf("qpTestLog_endImageSet(): Writing XML failed\n");
 810                 deMutex_unlock(log->lock);
 811                 return DE_FALSE;
 812         }
 813
 814         DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_IMAGESET);
 815
 816         deMutex_unlock(log->lock);
 817         return DE_TRUE;
 818 }
 819
 820 /*--------------------------------------------------------------------*//*!
 821  * \brief Write base64 encoded raw image data into log
 822  * \param log                           qpTestLog instance
 823  * \param name                          Unique name (matching names can be compared across BatchResults).
 824  * \param description           Textual description (shown in Candy).
 825  * \param compressionMode       Compression mode
 826  * \param imageFormat           Color format
 827  * \param width                         Width in pixels
 828  * \param height                        Height in pixels
 829  * \param stride                        Data stride (offset between rows)
 830  * \param data                          Pointer to pixel data
 831  * \return 0 if OK, otherwise <0
 832  *//*--------------------------------------------------------------------*/
 833 deBool qpTestLog_writeImage     (
 834         qpTestLog*                              log,
 835         const char*                             name,
 836         const char*                             description,
 837         qpImageCompressionMode  compressionMode,
 838         qpImageFormat                   imageFormat,
 839         int                                             width,
 840         int                                             height,
 841         int                                             stride,
 842         const void*                             data)
 843 {
 844         char                    widthStr[32];
 845         char                    heightStr[32];
 846         qpXmlAttribute  attribs[8];
 847         int                             numAttribs                      = 0;
 848         Buffer                  compressedBuffer;
 849         const void*             writeDataPtr            = DE_NULL;
 850         size_t                  writeDataBytes          = ~(size_t)0;
 851
 852         DE_ASSERT(log && name);
 853         DE_ASSERT(deInRange32(width, 1, 16384));
 854         DE_ASSERT(deInRange32(height, 1, 16384));
 855         DE_ASSERT(data);
 856
 857         if (log->flags & QP_TEST_LOG_EXCLUDE_IMAGES)
 858                 return DE_TRUE; /* Image not logged. */
 859
 860         Buffer_init(&compressedBuffer);
 861
 862         /* BEST compression mode defaults to PNG. */
 863         if (compressionMode == QP_IMAGE_COMPRESSION_MODE_BEST)
 864         {
 865 #if defined(QP_SUPPORT_PNG)
 866                 compressionMode = QP_IMAGE_COMPRESSION_MODE_PNG;
 867 #else
 868                 compressionMode = QP_IMAGE_COMPRESSION_MODE_NONE;
 869 #endif
 870         }
 871
 872 #if defined(QP_SUPPORT_PNG)
 873         /* Try storing with PNG compression. */
 874         if (compressionMode == QP_IMAGE_COMPRESSION_MODE_PNG)
 875         {
 876                 deBool compressOk = compressImagePNG(&compressedBuffer, imageFormat, width, height, stride, data);
 877                 if (compressOk)
 878                 {
 879                         writeDataPtr    = compressedBuffer.data;
 880                         writeDataBytes  = compressedBuffer.size;
 881                 }
 882                 else
 883                 {
 884                         /* Fall-back to default compression. */
 885                         qpPrintf("WARNING: PNG compression failed -- storing image uncompressed.\n");
 886                         compressionMode = QP_IMAGE_COMPRESSION_MODE_NONE;
 887                 }
 888         }
 889 #endif
 890
 891         /* Handle image compression. */
 892         switch (compressionMode)
 893         {
 894                 case QP_IMAGE_COMPRESSION_MODE_NONE:
 895                 {
 896                         int pixelSize           = imageFormat == QP_IMAGE_FORMAT_RGB888 ? 3 : 4;
 897                         int packedStride        = pixelSize*width;
 898
 899                         if (packedStride == stride)
 900                                 writeDataPtr = data;
 901                         else
 902                         {
 903                                 /* Need to re-pack pixels. */
 904                                 if (Buffer_resize(&compressedBuffer, (size_t)(packedStride*height)))
 905                                 {
 906                                         int row;
 907                                         for (row = 0; row < height; row++)
 908                                                 memcpy(&compressedBuffer.data[packedStride*row], &((const deUint8*)data)[row*stride], (size_t)(pixelSize*width));
 909                                 }
 910                                 else
 911                                 {
 912                                         qpPrintf("ERROR: Failed to pack pixels for writing.\n");
 913                                         Buffer_deinit(&compressedBuffer);
 914                                         return DE_FALSE;
 915                                 }
 916                         }
 917
 918                         writeDataBytes = (size_t)(packedStride*height);
 919                         break;
 920                 }
 921
 922 #if defined(QP_SUPPORT_PNG)
 923                 case QP_IMAGE_COMPRESSION_MODE_PNG:
 924                         DE_ASSERT(writeDataPtr); /* Already handled. */
 925                         break;
 926 #endif
 927
 928                 default:
 929                         qpPrintf("qpTestLog_writeImage(): Unknown compression mode: %s\n", QP_LOOKUP_STRING(s_qpImageCompressionModeMap, compressionMode));
 930                         Buffer_deinit(&compressedBuffer);
 931                         return DE_FALSE;
 932         }
 933
 934         /* Fill in attributes. */
 935         int32ToString(width, widthStr);
 936         int32ToString(height, heightStr);
 937         attribs[numAttribs++] = qpSetStringAttrib("Name", name);
 938         attribs[numAttribs++] = qpSetStringAttrib("Width", widthStr);
 939         attribs[numAttribs++] = qpSetStringAttrib("Height", heightStr);
 940         attribs[numAttribs++] = qpSetStringAttrib("Format", QP_LOOKUP_STRING(s_qpImageFormatMap, imageFormat));
 941         attribs[numAttribs++] = qpSetStringAttrib("CompressionMode", QP_LOOKUP_STRING(s_qpImageCompressionModeMap, compressionMode));
 942         if (description) attribs[numAttribs++] = qpSetStringAttrib("Description", description);
 943
 944         /* \note Log lock is acquired after compression! */
 945         deMutex_lock(log->lock);
 946
 947         /* <Image ID="result" Name="Foobar" Width="640" Height="480" Format="RGB888" CompressionMode="None">base64 data</Image> */
 948         if (!qpXmlWriter_startElement(log->writer, "Image", numAttribs, attribs) ||
 949                 !qpXmlWriter_writeBase64(log->writer, (const deUint8*)writeDataPtr, writeDataBytes) ||
 950                 !qpXmlWriter_endElement(log->writer, "Image"))
 951         {
 952                 qpPrintf("qpTestLog_writeImage(): Writing XML failed\n");
 953                 deMutex_unlock(log->lock);
 954                 Buffer_deinit(&compressedBuffer);
 955                 return DE_FALSE;
 956         }
 957
 958         deMutex_unlock(log->lock);
 959
 960         /* Free compressed data if allocated. */
 961         Buffer_deinit(&compressedBuffer);
 962
 963         return DE_TRUE;
 964 }
 965
 966 /*--------------------------------------------------------------------*//*!
 967  * \brief Write a OpenGL ES shader program into the log.
 968  * \param linkOk                        Shader program link result, false on failure
 969  * \param linkInfoLog           Implementation provided linkage log
 970  *//*--------------------------------------------------------------------*/
 971 deBool qpTestLog_startShaderProgram (qpTestLog* log, deBool linkOk, const char* linkInfoLog)
 972 {
 973         qpXmlAttribute  programAttribs[4];
 974         int                             numProgramAttribs = 0;
 975
 976         DE_ASSERT(log);
 977         deMutex_lock(log->lock);
 978
 979         programAttribs[numProgramAttribs++] = qpSetStringAttrib("LinkStatus", linkOk ? "OK" : "Fail");
 980
 981         if (!qpXmlWriter_startElement(log->writer, "ShaderProgram", numProgramAttribs, programAttribs) ||
 982                 !qpXmlWriter_writeStringElement(log->writer, "InfoLog", linkInfoLog))
 983         {
 984                 qpPrintf("qpTestLog_startShaderProgram(): Writing XML failed\n");
 985                 deMutex_unlock(log->lock);
 986                 return DE_FALSE;
 987         }
 988
 989         DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SHADERPROGRAM));
 990
 991         deMutex_unlock(log->lock);
 992         return DE_TRUE;
 993 }
 994
 995 /*--------------------------------------------------------------------*//*!
 996  * \brief End shader program
 997  * \param log                   qpTestLog instance
 998  * \return true if ok, false otherwise
 999  *//*--------------------------------------------------------------------*/
1000 deBool qpTestLog_endShaderProgram (qpTestLog* log)
1001 {
1002         DE_ASSERT(log);
1003         deMutex_lock(log->lock);
1004
1005         /* </ShaderProgram> */
1006         if (!qpXmlWriter_endElement(log->writer, "ShaderProgram"))
1007         {
1008                 qpPrintf("qpTestLog_endShaderProgram(): Writing XML failed\n");
1009                 deMutex_unlock(log->lock);
1010                 return DE_FALSE;
1011         }
1012
1013         DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SHADERPROGRAM);
1014
1015         deMutex_unlock(log->lock);
1016         return DE_TRUE;
1017 }
1018
1019 /*--------------------------------------------------------------------*//*!
1020  * \brief Write a OpenGL ES shader into the log.
1021  * \param type                          Shader type
1022  * \param source                        Shader source
1023  * \param compileOk                     Shader compilation result, false on failure
1024  * \param infoLog                       Implementation provided shader compilation log
1025  *//*--------------------------------------------------------------------*/
1026 deBool qpTestLog_writeShader (qpTestLog* log, qpShaderType type, const char* source, deBool compileOk, const char* infoLog)
1027 {
1028         const char*             tagName                         = QP_LOOKUP_STRING(s_qpShaderTypeMap, type);
1029         const char*             sourceStr                       = ((log->flags & QP_TEST_LOG_EXCLUDE_SHADER_SOURCES) == 0 || !compileOk) ? source : "";
1030         int                             numShaderAttribs        = 0;
1031         qpXmlAttribute  shaderAttribs[4];
1032
1033         DE_ASSERT(log && source);
1034         DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SHADERPROGRAM);
1035         deMutex_lock(log->lock);
1036
1037         shaderAttribs[numShaderAttribs++]       = qpSetStringAttrib("CompileStatus", compileOk ? "OK" : "Fail");
1038
1039         if (!qpXmlWriter_startElement(log->writer, tagName, numShaderAttribs, shaderAttribs) ||
1040                 !qpXmlWriter_writeStringElement(log->writer, "ShaderSource", sourceStr) ||
1041                 !qpXmlWriter_writeStringElement(log->writer, "InfoLog", infoLog) ||
1042                 !qpXmlWriter_endElement(log->writer, tagName))
1043         {
1044                 qpPrintf("qpTestLog_writeShader(): Writing XML failed\n");
1045                 deMutex_unlock(log->lock);
1046                 return DE_FALSE;
1047         }
1048
1049         deMutex_unlock(log->lock);
1050         return DE_TRUE;
1051 }
1052
1053 /*--------------------------------------------------------------------*//*!
1054  * \brief Start writing a set of EGL configurations into the log.
1055  *//*--------------------------------------------------------------------*/
1056 deBool qpTestLog_startEglConfigSet (qpTestLog* log, const char* name, const char* description)
1057 {
1058         qpXmlAttribute  attribs[4];
1059         int                             numAttribs = 0;
1060
1061         DE_ASSERT(log && name);
1062         deMutex_lock(log->lock);
1063
1064         attribs[numAttribs++] = qpSetStringAttrib("Name", name);
1065         if (description)
1066                 attribs[numAttribs++] = qpSetStringAttrib("Description", description);
1067
1068         /* <EglConfigSet Name="<name>"> */
1069         if (!qpXmlWriter_startElement(log->writer, "EglConfigSet", numAttribs, attribs))
1070         {
1071                 qpPrintf("qpTestLog_startEglImageSet(): Writing XML failed\n");
1072                 deMutex_unlock(log->lock);
1073                 return DE_FALSE;
1074         }
1075
1076         DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_EGLCONFIGSET));
1077
1078         deMutex_unlock(log->lock);
1079         return DE_TRUE;
1080 }
1081
1082 /*--------------------------------------------------------------------*//*!
1083  * \brief End an EGL config set
1084  *//*--------------------------------------------------------------------*/
1085 deBool qpTestLog_endEglConfigSet (qpTestLog* log)
1086 {
1087         DE_ASSERT(log);
1088         deMutex_lock(log->lock);
1089
1090         /* <EglConfigSet Name="<name>"> */
1091         if (!qpXmlWriter_endElement(log->writer, "EglConfigSet"))
1092         {
1093                 qpPrintf("qpTestLog_endEglImageSet(): Writing XML failed\n");
1094                 deMutex_unlock(log->lock);
1095                 return DE_FALSE;
1096         }
1097
1098         DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_EGLCONFIGSET);
1099
1100         deMutex_unlock(log->lock);
1101         return DE_TRUE;
1102 }
1103
1104 /*--------------------------------------------------------------------*//*!
1105  * \brief Write an EGL config inside an EGL config set
1106  * \see   qpElgConfigInfo for details
1107  *//*--------------------------------------------------------------------*/
1108 deBool qpTestLog_writeEglConfig (qpTestLog* log, const qpEglConfigInfo* config)
1109 {
1110         qpXmlAttribute  attribs[64];
1111         int                             numAttribs = 0;
1112
1113         DE_ASSERT(log && config);
1114         deMutex_lock(log->lock);
1115
1116         attribs[numAttribs++] = qpSetIntAttrib          ("BufferSize", config->bufferSize);
1117         attribs[numAttribs++] = qpSetIntAttrib          ("RedSize", config->redSize);
1118         attribs[numAttribs++] = qpSetIntAttrib          ("GreenSize", config->greenSize);
1119         attribs[numAttribs++] = qpSetIntAttrib          ("BlueSize", config->blueSize);
1120         attribs[numAttribs++] = qpSetIntAttrib          ("LuminanceSize", config->luminanceSize);
1121         attribs[numAttribs++] = qpSetIntAttrib          ("AlphaSize", config->alphaSize);
1122         attribs[numAttribs++] = qpSetIntAttrib          ("AlphaMaskSize", config->alphaMaskSize);
1123         attribs[numAttribs++] = qpSetBoolAttrib         ("BindToTextureRGB", config->bindToTextureRGB);
1124         attribs[numAttribs++] = qpSetBoolAttrib         ("BindToTextureRGBA", config->bindToTextureRGBA);
1125         attribs[numAttribs++] = qpSetStringAttrib       ("ColorBufferType", config->colorBufferType);
1126         attribs[numAttribs++] = qpSetStringAttrib       ("ConfigCaveat", config->configCaveat);
1127         attribs[numAttribs++] = qpSetIntAttrib          ("ConfigID", config->configID);
1128         attribs[numAttribs++] = qpSetStringAttrib       ("Conformant", config->conformant);
1129         attribs[numAttribs++] = qpSetIntAttrib          ("DepthSize", config->depthSize);
1130         attribs[numAttribs++] = qpSetIntAttrib          ("Level", config->level);
1131         attribs[numAttribs++] = qpSetIntAttrib          ("MaxPBufferWidth", config->maxPBufferWidth);
1132         attribs[numAttribs++] = qpSetIntAttrib          ("MaxPBufferHeight", config->maxPBufferHeight);
1133         attribs[numAttribs++] = qpSetIntAttrib          ("MaxPBufferPixels", config->maxPBufferPixels);
1134         attribs[numAttribs++] = qpSetIntAttrib          ("MaxSwapInterval", config->maxSwapInterval);
1135         attribs[numAttribs++] = qpSetIntAttrib          ("MinSwapInterval", config->minSwapInterval);
1136         attribs[numAttribs++] = qpSetBoolAttrib         ("NativeRenderable", config->nativeRenderable);
1137         attribs[numAttribs++] = qpSetStringAttrib       ("RenderableType", config->renderableType);
1138         attribs[numAttribs++] = qpSetIntAttrib          ("SampleBuffers", config->sampleBuffers);
1139         attribs[numAttribs++] = qpSetIntAttrib          ("Samples", config->samples);
1140         attribs[numAttribs++] = qpSetIntAttrib          ("StencilSize", config->stencilSize);
1141         attribs[numAttribs++] = qpSetStringAttrib       ("SurfaceTypes", config->surfaceTypes);
1142         attribs[numAttribs++] = qpSetStringAttrib       ("TransparentType", config->transparentType);
1143         attribs[numAttribs++] = qpSetIntAttrib          ("TransparentRedValue", config->transparentRedValue);
1144         attribs[numAttribs++] = qpSetIntAttrib          ("TransparentGreenValue", config->transparentGreenValue);
1145         attribs[numAttribs++] = qpSetIntAttrib          ("TransparentBlueValue", config->transparentBlueValue);
1146         DE_ASSERT(numAttribs <= DE_LENGTH_OF_ARRAY(attribs));
1147
1148         if (!qpXmlWriter_startElement(log->writer, "EglConfig", numAttribs, attribs) ||
1149                 !qpXmlWriter_endElement(log->writer, "EglConfig"))
1150         {
1151                 qpPrintf("qpTestLog_writeEglConfig(): Writing XML failed\n");
1152                 deMutex_unlock(log->lock);
1153                 return DE_FALSE;
1154         }
1155
1156         deMutex_unlock(log->lock);
1157         return DE_TRUE;
1158 }
1159
1160 /*--------------------------------------------------------------------*//*!
1161  * \brief Start section in log.
1162  * \param log                   qpTestLog instance
1163  * \param name                  Section name
1164  * \param description   Human readable description
1165  * \return true if ok, false otherwise
1166  *//*--------------------------------------------------------------------*/
1167 deBool qpTestLog_startSection (qpTestLog* log, const char* name, const char* description)
1168 {
1169         qpXmlAttribute  attribs[2];
1170         int                             numAttribs = 0;
1171
1172         DE_ASSERT(log && name);
1173         deMutex_lock(log->lock);
1174
1175         attribs[numAttribs++] = qpSetStringAttrib("Name", name);
1176         if (description)
1177                 attribs[numAttribs++] = qpSetStringAttrib("Description", description);
1178
1179         /* <Section Name="<name>" Description="<description>"> */
1180         if (!qpXmlWriter_startElement(log->writer, "Section", numAttribs, attribs))
1181         {
1182                 qpPrintf("qpTestLog_startSection(): Writing XML failed\n");
1183                 deMutex_unlock(log->lock);
1184                 return DE_FALSE;
1185         }
1186
1187         DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SECTION));
1188
1189         deMutex_unlock(log->lock);
1190         return DE_TRUE;
1191 }
1192
1193 /*--------------------------------------------------------------------*//*!
1194  * \brief End section in log.
1195  * \param log                   qpTestLog instance
1196  * \return true if ok, false otherwise
1197  *//*--------------------------------------------------------------------*/
1198 deBool qpTestLog_endSection (qpTestLog* log)
1199 {
1200         DE_ASSERT(log);
1201         deMutex_lock(log->lock);
1202
1203         /* </Section> */
1204         if (!qpXmlWriter_endElement(log->writer, "Section"))
1205         {
1206                 qpPrintf("qpTestLog_endSection(): Writing XML failed\n");
1207                 deMutex_unlock(log->lock);
1208                 return DE_FALSE;
1209         }
1210
1211         DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SECTION);
1212
1213         deMutex_unlock(log->lock);
1214         return DE_TRUE;
1215 }
1216
1217 /*--------------------------------------------------------------------*//*!
1218  * \brief Write OpenCL compute kernel source into the log.
1219  *//*--------------------------------------------------------------------*/
1220 deBool qpTestLog_writeKernelSource (qpTestLog* log, const char* source)
1221 {
1222         const char*             sourceStr       = (log->flags & QP_TEST_LOG_EXCLUDE_SHADER_SOURCES) != 0 ? "" : source;
1223
1224         DE_ASSERT(log);
1225         deMutex_lock(log->lock);
1226
1227         if (!qpXmlWriter_writeStringElement(log->writer, "KernelSource", sourceStr))
1228         {
1229                 qpPrintf("qpTestLog_writeKernelSource(): Writing XML failed\n");
1230                 deMutex_unlock(log->lock);
1231                 return DE_FALSE;
1232         }
1233
1234         deMutex_unlock(log->lock);
1235         return DE_TRUE;
1236 }
1237
1238 /*--------------------------------------------------------------------*//*!
1239  * \brief Write a SPIR-V module assembly source into the log.
1240  *//*--------------------------------------------------------------------*/
1241 deBool qpTestLog_writeSpirVAssemblySource (qpTestLog* log, const char* source)
1242 {
1243         DE_ASSERT(log);
1244         DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SHADERPROGRAM);
1245         deMutex_lock(log->lock);
1246
1247         if (!qpXmlWriter_writeStringElement(log->writer, "SpirVAssemblySource", source))
1248         {
1249                 qpPrintf("qpTestLog_writeSpirVAssemblySource(): Writing XML failed\n");
1250                 deMutex_unlock(log->lock);
1251                 return DE_FALSE;
1252         }
1253
1254         deMutex_unlock(log->lock);
1255         return DE_TRUE;
1256 }
1257
1258 /*--------------------------------------------------------------------*//*!
1259  * \brief Write OpenCL kernel compilation results into the log
1260  *//*--------------------------------------------------------------------*/
1261 deBool qpTestLog_writeCompileInfo (qpTestLog* log, const char* name, const char* description, deBool compileOk, const char* infoLog)
1262 {
1263         int                             numAttribs = 0;
1264         qpXmlAttribute  attribs[3];
1265
1266         DE_ASSERT(log && name && description && infoLog);
1267         deMutex_lock(log->lock);
1268
1269         attribs[numAttribs++] = qpSetStringAttrib("Name", name);
1270         attribs[numAttribs++] = qpSetStringAttrib("Description", description);
1271         attribs[numAttribs++] = qpSetStringAttrib("CompileStatus", compileOk ? "OK" : "Fail");
1272
1273         if (!qpXmlWriter_startElement(log->writer, "CompileInfo", numAttribs, attribs) ||
1274                 !qpXmlWriter_writeStringElement(log->writer, "InfoLog", infoLog) ||
1275                 !qpXmlWriter_endElement(log->writer, "CompileInfo"))
1276         {
1277                 qpPrintf("qpTestLog_writeCompileInfo(): Writing XML failed\n");
1278                 deMutex_unlock(log->lock);
1279                 return DE_FALSE;
1280         }
1281
1282         deMutex_unlock(log->lock);
1283         return DE_TRUE;
1284 }
1285
1286 deBool qpTestLog_startSampleList (qpTestLog* log, const char* name, const char* description)
1287 {
1288         int                             numAttribs = 0;
1289         qpXmlAttribute  attribs[2];
1290
1291         DE_ASSERT(log && name && description);
1292         deMutex_lock(log->lock);
1293
1294         attribs[numAttribs++] = qpSetStringAttrib("Name", name);
1295         attribs[numAttribs++] = qpSetStringAttrib("Description", description);
1296
1297         if (!qpXmlWriter_startElement(log->writer, "SampleList", numAttribs, attribs))
1298         {
1299                 qpPrintf("qpTestLog_startSampleList(): Writing XML failed\n");
1300                 deMutex_unlock(log->lock);
1301                 return DE_FALSE;
1302         }
1303
1304         DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SAMPLELIST));
1305
1306         deMutex_unlock(log->lock);
1307         return DE_TRUE;
1308 }
1309
1310 deBool qpTestLog_startSampleInfo (qpTestLog* log)
1311 {
1312         DE_ASSERT(log);
1313         deMutex_lock(log->lock);
1314
1315         if (!qpXmlWriter_startElement(log->writer, "SampleInfo", 0, DE_NULL))
1316         {
1317                 qpPrintf("qpTestLog_startSampleInfo(): Writing XML failed\n");
1318                 deMutex_unlock(log->lock);
1319                 return DE_FALSE;
1320         }
1321
1322         DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SAMPLEINFO));
1323
1324         deMutex_unlock(log->lock);
1325         return DE_TRUE;
1326 }
1327
1328 deBool qpTestLog_writeValueInfo (qpTestLog* log, const char* name, const char* description, const char* unit, qpSampleValueTag tag)
1329 {
1330         const char*             tagName         = QP_LOOKUP_STRING(s_qpSampleValueTagMap, tag);
1331         int                             numAttribs      = 0;
1332         qpXmlAttribute  attribs[4];
1333
1334         DE_ASSERT(log && name && description && tagName);
1335         deMutex_lock(log->lock);
1336
1337         DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLEINFO);
1338
1339         attribs[numAttribs++] = qpSetStringAttrib("Name", name);
1340         attribs[numAttribs++] = qpSetStringAttrib("Description", description);
1341         attribs[numAttribs++] = qpSetStringAttrib("Tag", tagName);
1342
1343         if (unit)
1344                 attribs[numAttribs++] = qpSetStringAttrib("Unit", unit);
1345
1346         if (!qpXmlWriter_startElement(log->writer, "ValueInfo", numAttribs, attribs) ||
1347                 !qpXmlWriter_endElement(log->writer, "ValueInfo"))
1348         {
1349                 qpPrintf("qpTestLog_writeValueInfo(): Writing XML failed\n");
1350                 deMutex_unlock(log->lock);
1351                 return DE_FALSE;
1352         }
1353
1354         deMutex_unlock(log->lock);
1355         return DE_TRUE;
1356 }
1357
1358 deBool qpTestLog_endSampleInfo (qpTestLog* log)
1359 {
1360         DE_ASSERT(log);
1361         deMutex_lock(log->lock);
1362
1363         if (!qpXmlWriter_endElement(log->writer, "SampleInfo"))
1364         {
1365                 qpPrintf("qpTestLog_endSampleInfo(): Writing XML failed\n");
1366                 deMutex_unlock(log->lock);
1367                 return DE_FALSE;
1368         }
1369
1370         DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SAMPLEINFO);
1371
1372         deMutex_unlock(log->lock);
1373         return DE_TRUE;
1374 }
1375
1376 deBool qpTestLog_startSample (qpTestLog* log)
1377 {
1378         DE_ASSERT(log);
1379         deMutex_lock(log->lock);
1380
1381         DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLELIST);
1382
1383         if (!qpXmlWriter_startElement(log->writer, "Sample", 0, DE_NULL))
1384         {
1385                 qpPrintf("qpTestLog_startSample(): Writing XML failed\n");
1386                 deMutex_unlock(log->lock);
1387                 return DE_FALSE;
1388         }
1389
1390         DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SAMPLE));
1391
1392         deMutex_unlock(log->lock);
1393         return DE_TRUE;
1394 }
1395
1396 deBool qpTestLog_writeValueFloat (qpTestLog* log, double value)
1397 {
1398         char tmpString[512];
1399         doubleToString(value, tmpString, (int)sizeof(tmpString));
1400
1401         deMutex_lock(log->lock);
1402
1403         DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLE);
1404
1405         if (!qpXmlWriter_writeStringElement(log->writer, "Value", &tmpString[0]))
1406         {
1407                 qpPrintf("qpTestLog_writeSampleValue(): Writing XML failed\n");
1408                 deMutex_unlock(log->lock);
1409                 return DE_FALSE;
1410         }
1411
1412         deMutex_unlock(log->lock);
1413         return DE_TRUE;
1414 }
1415
1416 deBool qpTestLog_writeValueInteger (qpTestLog* log, deInt64 value)
1417 {
1418         char tmpString[64];
1419         int64ToString(value, tmpString);
1420
1421         deMutex_lock(log->lock);
1422
1423         DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLE);
1424
1425         if (!qpXmlWriter_writeStringElement(log->writer, "Value", &tmpString[0]))
1426         {
1427                 qpPrintf("qpTestLog_writeSampleValue(): Writing XML failed\n");
1428                 deMutex_unlock(log->lock);
1429                 return DE_FALSE;
1430         }
1431
1432         deMutex_unlock(log->lock);
1433         return DE_TRUE;
1434 }
1435
1436 deBool qpTestLog_endSample (qpTestLog* log)
1437 {
1438         DE_ASSERT(log);
1439         deMutex_lock(log->lock);
1440
1441         if (!qpXmlWriter_endElement(log->writer, "Sample"))
1442         {
1443                 qpPrintf("qpTestLog_endSample(): Writing XML failed\n");
1444                 deMutex_unlock(log->lock);
1445                 return DE_FALSE;
1446         }
1447
1448         DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SAMPLE);
1449
1450         deMutex_unlock(log->lock);
1451         return DE_TRUE;
1452 }
1453
1454 deBool qpTestLog_endSampleList (qpTestLog* log)
1455 {
1456         DE_ASSERT(log);
1457         deMutex_lock(log->lock);
1458
1459         if (!qpXmlWriter_endElement(log->writer, "SampleList"))
1460         {
1461                 qpPrintf("qpTestLog_endSampleList(): Writing XML failed\n");
1462                 deMutex_unlock(log->lock);
1463                 return DE_FALSE;
1464         }
1465
1466         DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SAMPLELIST);
1467
1468         deMutex_unlock(log->lock);
1469         return DE_TRUE;
1470 }
1471
1472 deUint32 qpTestLog_getLogFlags (const qpTestLog* log)
1473 {
1474         DE_ASSERT(log);
1475         return log->flags;
1476 }
1477
1478 const char* qpGetTestResultName (qpTestResult result)
1479 {
1480         return QP_LOOKUP_STRING(s_qpTestResultMap, result);
1481 }