xref: /aosp_15_r20/external/deqp/framework/qphelper/qpTestLog.c (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements TestLog Library
 * ----------------------------
 *
 * 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 Test case result logging
 *//*--------------------------------------------------------------------*/

#include "qpTestLog.h"
#include "qpXmlWriter.h"
#include "qpInfo.h"
#include "qpDebugOut.h"

#include "deMemory.h"
#include "deInt32.h"
#include "deString.h"

#include "deMutex.h"

#include "deClock.h"

#if defined(QP_SUPPORT_PNG)
#include <png.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#if (DE_OS == DE_OS_WIN32)
#include <windows.h>
#include <io.h>
#endif

static uint64_t sessionStartTime;

#if defined(DE_DEBUG)

/* Utils for verifying container (Section, ImageSet, EglConfigSet) usage in debug builds. */

typedef enum ContainerType_e
{
    CONTAINERTYPE_SECTION = 0,
    CONTAINERTYPE_IMAGESET,
    CONTAINERTYPE_EGLCONFIGSET,
    CONTAINERTYPE_SHADERPROGRAM,
    CONTAINERTYPE_SAMPLELIST,
    CONTAINERTYPE_SAMPLEINFO,
    CONTAINERTYPE_SAMPLE,

    CONTAINERTYPE_LAST
} ContainerType;

DE_INLINE bool childContainersOk(ContainerType type)
{
    return type == CONTAINERTYPE_SECTION || type == CONTAINERTYPE_SAMPLELIST;
}

enum
{
    MAX_CONTAINER_STACK_DEPTH = 32
};

typedef struct ContainerStack_s
{
    int numElements;
    ContainerType elements[MAX_CONTAINER_STACK_DEPTH];
} ContainerStack;

DE_INLINE void ContainerStack_reset(ContainerStack *stack)
{
    deMemset(stack, 0, sizeof(ContainerStack));
}

DE_INLINE bool ContainerStack_isEmpty(const ContainerStack *stack)
{
    return stack->numElements == 0;
}

DE_INLINE bool ContainerStack_push(ContainerStack *stack, ContainerType type)
{
    if (stack->numElements == MAX_CONTAINER_STACK_DEPTH)
        return false;

    if (stack->numElements > 0 && !childContainersOk(stack->elements[stack->numElements - 1]))
        return false;

    stack->elements[stack->numElements] = type;
    stack->numElements += 1;

    return true;
}

DE_INLINE ContainerType ContainerStack_pop(ContainerStack *stack)
{
    DE_ASSERT(stack->numElements > 0);
    stack->numElements -= 1;
    return stack->elements[stack->numElements];
}

DE_INLINE ContainerType ContainerStack_getTop(const ContainerStack *stack)
{
    if (stack->numElements > 0)
        return stack->elements[stack->numElements - 1];
    else
        return CONTAINERTYPE_LAST;
}

#endif

/* qpTestLog instance */
struct qpTestLog_s
{
    uint32_t flags; /*!< Logging flags.                        */

    deMutex lock; /*!< Lock for mutable state below.        */

    /* State protected by lock. */
    FILE *outputFile;
    qpXmlWriter *writer;
    bool isSessionOpen;
    bool isCaseOpen;

#if defined(DE_DEBUG)
    ContainerStack containerStack; /*!< For container usage verification.    */
#endif
};

/* Maps integer to string. */
typedef struct qpKeyStringMap_s
{
    int key;
    char *string;
} qpKeyStringMap;

static const char *LOG_FORMAT_VERSION = "0.3.4";

/* Mapping enum to above strings... */
static const qpKeyStringMap s_qpTestTypeMap[] = {{QP_TEST_CASE_TYPE_SELF_VALIDATE, "SelfValidate"},
                                                 {QP_TEST_CASE_TYPE_PERFORMANCE, "Performance"},
                                                 {QP_TEST_CASE_TYPE_CAPABILITY, "Capability"},
                                                 {QP_TEST_CASE_TYPE_ACCURACY, "Accuracy"},

                                                 {QP_TEST_CASE_TYPE_LAST, DE_NULL}};

DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpTestTypeMap) == QP_TEST_CASE_TYPE_LAST + 1);

static const qpKeyStringMap s_qpTestResultMap[] = {
    {QP_TEST_RESULT_PASS, "Pass"},
    {QP_TEST_RESULT_FAIL, "Fail"},
    {QP_TEST_RESULT_QUALITY_WARNING, "QualityWarning"},
    {QP_TEST_RESULT_COMPATIBILITY_WARNING, "CompatibilityWarning"},
    {QP_TEST_RESULT_PENDING, "Pending"}, /* should not be needed here */
    {QP_TEST_RESULT_NOT_SUPPORTED, "NotSupported"},
    {QP_TEST_RESULT_RESOURCE_ERROR, "ResourceError"},
    {QP_TEST_RESULT_INTERNAL_ERROR, "InternalError"},
    {QP_TEST_RESULT_CRASH, "Crash"},
    {QP_TEST_RESULT_TIMEOUT, "Timeout"},
    {QP_TEST_RESULT_WAIVER, "Waiver"},
    {QP_TEST_RESULT_DEVICE_LOST, "DeviceLost"},

    /* Add new values here if needed, remember to update qpTestResult enumeration. */

    {QP_TEST_RESULT_LAST, DE_NULL}};

DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpTestResultMap) == QP_TEST_RESULT_LAST + 1);

/* Key tag to string mapping. */

static const qpKeyStringMap s_qpTagMap[] = {{QP_KEY_TAG_NONE, DE_NULL},      {QP_KEY_TAG_PERFORMANCE, "Performance"},
                                            {QP_KEY_TAG_QUALITY, "Quality"}, {QP_KEY_TAG_PRECISION, "Precision"},
                                            {QP_KEY_TAG_TIME, "Time"},

                                            {QP_KEY_TAG_LAST, DE_NULL}};

DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpTagMap) == QP_KEY_TAG_LAST + 1);

/* Sample value tag to string mapping. */

static const qpKeyStringMap s_qpSampleValueTagMap[] = {{QP_SAMPLE_VALUE_TAG_PREDICTOR, "Predictor"},
                                                       {QP_SAMPLE_VALUE_TAG_RESPONSE, "Response"},

                                                       {QP_SAMPLE_VALUE_TAG_LAST, DE_NULL}};

DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpSampleValueTagMap) == QP_SAMPLE_VALUE_TAG_LAST + 1);

/* Image compression mode to string mapping. */

static const qpKeyStringMap s_qpImageCompressionModeMap[] = {
    {QP_IMAGE_COMPRESSION_MODE_NONE, "None"},
    {QP_IMAGE_COMPRESSION_MODE_PNG, "PNG"},

    {QP_IMAGE_COMPRESSION_MODE_BEST, DE_NULL}, /* not allowed to be written! */

    {QP_IMAGE_COMPRESSION_MODE_LAST, DE_NULL}};

DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpImageCompressionModeMap) == QP_IMAGE_COMPRESSION_MODE_LAST + 1);

/* Image format to string mapping. */

static const qpKeyStringMap s_qpImageFormatMap[] = {{QP_IMAGE_FORMAT_RGB888, "RGB888"},
                                                    {QP_IMAGE_FORMAT_RGBA8888, "RGBA8888"},

                                                    {QP_IMAGE_FORMAT_LAST, DE_NULL}};

DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpImageFormatMap) == QP_IMAGE_FORMAT_LAST + 1);

/* Shader type to string mapping. */

static const qpKeyStringMap s_qpShaderTypeMap[] = {{QP_SHADER_TYPE_VERTEX, "VertexShader"},
                                                   {QP_SHADER_TYPE_FRAGMENT, "FragmentShader"},
                                                   {QP_SHADER_TYPE_GEOMETRY, "GeometryShader"},
                                                   {QP_SHADER_TYPE_TESS_CONTROL, "TessControlShader"},
                                                   {QP_SHADER_TYPE_TESS_EVALUATION, "TessEvaluationShader"},
                                                   {QP_SHADER_TYPE_COMPUTE, "ComputeShader"},
                                                   {QP_SHADER_TYPE_RAYGEN, "RaygenShader"},
                                                   {QP_SHADER_TYPE_ANY_HIT, "AnyHitShader"},
                                                   {QP_SHADER_TYPE_CLOSEST_HIT, "ClosestHitShader"},
                                                   {QP_SHADER_TYPE_MISS, "MissShader"},
                                                   {QP_SHADER_TYPE_INTERSECTION, "IntersectionShader"},
                                                   {QP_SHADER_TYPE_CALLABLE, "CallableShader"},
                                                   {QP_SHADER_TYPE_TASK, "TaskShader"},
                                                   {QP_SHADER_TYPE_MESH, "MeshShader"},

                                                   {QP_SHADER_TYPE_LAST, DE_NULL}};

DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qpShaderTypeMap) == QP_SHADER_TYPE_LAST + 1);

static void qpTestLog_flushFile(qpTestLog *log)
{
    DE_ASSERT(log && log->outputFile);
    fflush(log->outputFile);
#if (DE_OS == DE_OS_WIN32) && (DE_COMPILER == DE_COMPILER_MSC)
    /* \todo [petri] Is this really necessary? */
    FlushFileBuffers((HANDLE)_get_osfhandle(_fileno(log->outputFile)));
#endif
}

#define QP_LOOKUP_STRING(KEYMAP, KEY) qpLookupString(KEYMAP, DE_LENGTH_OF_ARRAY(KEYMAP), (int)(KEY))

static const char *qpLookupString(const qpKeyStringMap *keyMap, int keyMapSize, int key)
{
    DE_ASSERT(keyMap);
    DE_ASSERT(deInBounds32(key, 0, keyMapSize - 1)); /* Last element in map is assumed to be terminator */
    DE_ASSERT(keyMap[keyMapSize - 1].string ==
              DE_NULL); /* Ensure map is properly completed, *_LAST element is not missing */
    DE_ASSERT(keyMap[key].key == key);
    DE_UNREF(keyMapSize); /* for asserting only */
    return keyMap[key].string;
}

DE_INLINE void int32ToString(int val, char buf[32])
{
    deSprintf(&buf[0], 32, "%d", val);
}

DE_INLINE void int64ToString(int64_t val, char buf[32])
{
    deSprintf(&buf[0], 32, "%lld", (long long int)val);
}

DE_INLINE void floatToString(float value, char *buf, size_t bufSize)
{
    deSprintf(buf, bufSize, "%f", value);
}

DE_INLINE void doubleToString(double value, char *buf, size_t bufSize)
{
    deSprintf(buf, bufSize, "%f", value);
}

static bool endSession(qpTestLog *log)
{
    DE_ASSERT(log && log->isSessionOpen);

    /* Make sure xml is flushed. */
    qpXmlWriter_flush(log->writer);

    uint64_t duration = deGetMicroseconds() - sessionStartTime;

    fprintf(log->outputFile, "\nRun took %.2f seconds\n", (float)duration / 1000000.0f);

    /* Write out #endSession. */
    fprintf(log->outputFile, "\n#endSession\n");
    qpTestLog_flushFile(log);

    log->isSessionOpen = false;

    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Create a file based logger instance
 * \param fileName Name of the file where to put logs
 * \return qpTestLog instance, or DE_NULL if cannot create file
 *//*--------------------------------------------------------------------*/
qpTestLog *qpTestLog_createFileLog(const char *fileName, uint32_t flags)
{
    qpTestLog *log = (qpTestLog *)deCalloc(sizeof(qpTestLog));
    if (!log)
        return DE_NULL;

    DE_ASSERT(fileName && fileName[0]); /* must have filename. */

#if defined(DE_DEBUG)
    ContainerStack_reset(&log->containerStack);
#endif

    if (!(flags & QP_TEST_LOG_NO_INITIAL_OUTPUT))
        qpPrintf("Writing test log into %s\n", fileName);

    /* Create output file. */
    log->outputFile = fopen(fileName, "wb");
    if (!log->outputFile)
    {
        qpPrintf("ERROR: Unable to open test log output file '%s'.\n", fileName);
        qpTestLog_destroy(log);
        return DE_NULL;
    }

    log->flags         = flags;
    log->writer        = qpXmlWriter_createFileWriter(log->outputFile, 0, !(flags & QP_TEST_LOG_NO_FLUSH));
    log->lock          = deMutex_create(DE_NULL);
    log->isSessionOpen = false;
    log->isCaseOpen    = false;

    if (!log->writer)
    {
        qpPrintf("ERROR: Unable to create output XML writer to file '%s'.\n", fileName);
        qpTestLog_destroy(log);
        return DE_NULL;
    }

    if (!log->lock)
    {
        qpPrintf("ERROR: Unable to create mutex.\n");
        qpTestLog_destroy(log);
        return DE_NULL;
    }

    return log;
}

/*--------------------------------------------------------------------*//*!
 * \brief Log information about test session
 * \param log qpTestLog instance
 * \param additionalSessionInfo string contatining additional sessionInfo data
 *//*--------------------------------------------------------------------*/
bool qpTestLog_beginSession(qpTestLog *log, const char *additionalSessionInfo)
{
    DE_ASSERT(log);

    /* Make sure this function is called once*/
    if (log->isSessionOpen)
        return true;

    /* Write session info. */
    fprintf(log->outputFile, "#sessionInfo releaseName %s\n", qpGetReleaseName());
    fprintf(log->outputFile, "#sessionInfo releaseId 0x%08x\n", qpGetReleaseId());
    fprintf(log->outputFile, "#sessionInfo targetName \"%s\"\n", qpGetTargetName());
    char *compactStr = "";
    if (qpTestLog_isCompact(log))
    {
        compactStr = "-compact";
    }
    fprintf(log->outputFile, "#sessionInfo logFormatVersion \"%s%s\"\n", LOG_FORMAT_VERSION, compactStr);

    if (strlen(additionalSessionInfo) > 1)
        fprintf(log->outputFile, "%s\n", additionalSessionInfo);

    /* Write out #beginSession. */
    fprintf(log->outputFile, "#beginSession\n");
    qpTestLog_flushFile(log);
    sessionStartTime = deGetMicroseconds();

    log->isSessionOpen = true;

    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Destroy a logger instance
 * \param log qpTestLog instance
 *//*--------------------------------------------------------------------*/
void qpTestLog_destroy(qpTestLog *log)
{
    DE_ASSERT(log);

    if (log->isSessionOpen)
        endSession(log);

    if (log->writer)
        qpXmlWriter_destroy(log->writer);

    if (log->outputFile)
        fclose(log->outputFile);

    if (log->lock)
        deMutex_destroy(log->lock);

    deFree(log);
}

/*--------------------------------------------------------------------*//*!
 * \brief Log start of test case
 * \param log qpTestLog instance
 * \param testCasePath    Full test case path (as seen in Candy).
 * \param testCaseType    Test case type
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_startCase(qpTestLog *log, const char *testCasePath, qpTestCaseType testCaseType)
{
    const char *typeStr  = QP_LOOKUP_STRING(s_qpTestTypeMap, testCaseType);
    int numResultAttribs = 0;
    qpXmlAttribute resultAttribs[8];

    DE_ASSERT(log && testCasePath && (testCasePath[0] != 0));
    deMutex_lock(log->lock);

    DE_ASSERT(!log->isCaseOpen);
    DE_ASSERT(ContainerStack_isEmpty(&log->containerStack));

    /* Flush XML and write out #beginTestCaseResult. */
    qpXmlWriter_flush(log->writer);
    if (!qpTestLog_isCompact(log))
    {
        fprintf(log->outputFile, "\n#beginTestCaseResult %s\n", testCasePath);
    }
    if (!(log->flags & QP_TEST_LOG_NO_FLUSH))
        qpTestLog_flushFile(log);

    log->isCaseOpen = true;

    /* Fill in attributes. */
    resultAttribs[numResultAttribs++] = qpSetStringAttrib("CasePath", testCasePath);
    if (!qpTestLog_isCompact(log))
    {
        resultAttribs[numResultAttribs++] = qpSetStringAttrib("Version", LOG_FORMAT_VERSION);
        resultAttribs[numResultAttribs++] = qpSetStringAttrib("CaseType", typeStr);
    }

    if (!qpXmlWriter_startDocument(log->writer, !qpTestLog_isCompact(log)) ||
        !qpXmlWriter_startElement(log->writer, "TestCaseResult", numResultAttribs, resultAttribs))
    {
        qpPrintf("qpTestLog_startCase(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Log end of test case
 * \param log qpTestLog instance
 * \param result Test result
 * \param description Description of a problem in case of error
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_endCase(qpTestLog *log, qpTestResult result, const char *resultDetails)
{
    const char *statusStr       = QP_LOOKUP_STRING(s_qpTestResultMap, result);
    qpXmlAttribute statusAttrib = qpSetStringAttrib("StatusCode", statusStr);

    deMutex_lock(log->lock);

    DE_ASSERT(log->isCaseOpen);
    DE_ASSERT(ContainerStack_isEmpty(&log->containerStack));

    /* <Result StatusCode="Pass">Result details</Result>
     * </TestCaseResult>
     */
    if (!qpXmlWriter_startElement(log->writer, "Result", 1, &statusAttrib) ||
        (resultDetails && !qpXmlWriter_writeString(log->writer, resultDetails)) ||
        !qpXmlWriter_endElement(log->writer, "Result") || !qpXmlWriter_endElement(log->writer, "TestCaseResult") ||
        !qpXmlWriter_endDocument(log->writer)) /* Close any XML elements still open */
    {
        qpPrintf("qpTestLog_endCase(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    /* Flush XML and write #endTestCaseResult. */
    qpXmlWriter_flush(log->writer);
    if (!qpTestLog_isCompact(log))
    {
        fprintf(log->outputFile, "\n#endTestCaseResult\n");
    }
    if (!(log->flags & QP_TEST_LOG_NO_FLUSH))
        qpTestLog_flushFile(log);

    log->isCaseOpen = false;

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_startTestsCasesTime(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    /* Flush XML and write out #beginTestCaseResult. */
    qpXmlWriter_flush(log->writer);
    fprintf(log->outputFile, "\n#beginTestsCasesTime\n");

    log->isCaseOpen = true;

    if (!qpXmlWriter_startDocument(log->writer, !qpTestLog_isCompact(log)) ||
        !qpXmlWriter_startElement(log->writer, "TestsCasesTime", 0, (const qpXmlAttribute *)DE_NULL))
    {
        qpPrintf("qpTestLog_startTestsCasesTime(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_endTestsCasesTime(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    DE_ASSERT(log->isCaseOpen);

    if (!qpXmlWriter_endElement(log->writer, "TestsCasesTime") || !qpXmlWriter_endDocument(log->writer))
    {
        qpPrintf("qpTestLog_endTestsCasesTime(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    qpXmlWriter_flush(log->writer);

    fprintf(log->outputFile, "\n#endTestsCasesTime\n");

    log->isCaseOpen = false;

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Abrupt termination of logging.
 * \param log        qpTestLog instance
 * \param result    Result code, only Crash and Timeout are allowed.
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_terminateCase(qpTestLog *log, qpTestResult result)
{
    const char *resultStr = QP_LOOKUP_STRING(s_qpTestResultMap, result);

    DE_ASSERT(log);
    DE_ASSERT(result == QP_TEST_RESULT_CRASH || result == QP_TEST_RESULT_TIMEOUT);

    deMutex_lock(log->lock);

    if (!log->isCaseOpen)
    {
        deMutex_unlock(log->lock);
        return false; /* Soft error. This is called from error handler. */
    }

    /* Flush XML and write #terminateTestCaseResult. */
    qpXmlWriter_flush(log->writer);
    fprintf(log->outputFile, "\n#terminateTestCaseResult %s\n", resultStr);
    qpTestLog_flushFile(log);

    log->isCaseOpen = false;

#if defined(DE_DEBUG)
    ContainerStack_reset(&log->containerStack);
#endif

    deMutex_unlock(log->lock);
    return true;
}

static bool qpTestLog_writeKeyValuePair(qpTestLog *log, const char *elementName, const char *name,
                                        const char *description, const char *unit, qpKeyValueTag tag, const char *text)
{
    const char *tagString = QP_LOOKUP_STRING(s_qpTagMap, tag);
    qpXmlAttribute attribs[8];
    int numAttribs = 0;

    DE_ASSERT(log && elementName && text);
    deMutex_lock(log->lock);

    /* Fill in attributes. */
    if (name)
        attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    if (description)
        attribs[numAttribs++] = qpSetStringAttrib("Description", description);
    if (tagString)
        attribs[numAttribs++] = qpSetStringAttrib("Tag", tagString);
    if (unit)
        attribs[numAttribs++] = qpSetStringAttrib("Unit", unit);

    if (!qpXmlWriter_startElement(log->writer, elementName, numAttribs, attribs) ||
        !qpXmlWriter_writeString(log->writer, text) || !qpXmlWriter_endElement(log->writer, elementName))
    {
        qpPrintf("qpTestLog_writeKeyValuePair(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Write key-value-pair into log
 * \param log            qpTestLog instance
 * \param name            Unique identifier for entry
 * \param description    Human readable description
 * \param tag            Optional tag
 * \param value            Value of the key-value-pair
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeText(qpTestLog *log, const char *name, const char *description, qpKeyValueTag tag, const char *text)
{
    /* <Text Name="name" Description="description" Tag="tag">text</Text> */
    return qpTestLog_writeKeyValuePair(log, "Text", name, description, DE_NULL, tag, text);
}

/*--------------------------------------------------------------------*//*!
 * \brief Write key-value-pair into log
 * \param log            qpTestLog instance
 * \param name            Unique identifier for entry
 * \param description    Human readable description
 * \param tag            Optional tag
 * \param value            Value of the key-value-pair
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeInteger(qpTestLog *log, const char *name, const char *description, const char *unit,
                            qpKeyValueTag tag, int64_t value)
{
    char tmpString[64];
    int64ToString(value, tmpString);

    /* <Number Name="name" Description="description" Tag="Performance">15</Number> */
    return qpTestLog_writeKeyValuePair(log, "Number", name, description, unit, tag, tmpString);
}

/*--------------------------------------------------------------------*//*!
 * \brief Write key-value-pair into log
 * \param log            qpTestLog instance
 * \param name            Unique identifier for entry
 * \param description    Human readable description
 * \param tag            Optional tag
 * \param value            Value of the key-value-pair
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeFloat(qpTestLog *log, const char *name, const char *description, const char *unit,
                          qpKeyValueTag tag, float value)
{
    char tmpString[64];
    floatToString(value, tmpString, sizeof(tmpString));

    /* <Number Name="name" Description="description" Tag="Performance">15</Number> */
    return qpTestLog_writeKeyValuePair(log, "Number", name, description, unit, tag, tmpString);
}

typedef struct Buffer_s
{
    size_t capacity;
    size_t size;
    uint8_t *data;
} Buffer;

void Buffer_init(Buffer *buffer)
{
    buffer->capacity = 0;
    buffer->size     = 0;
    buffer->data     = DE_NULL;
}

void Buffer_deinit(Buffer *buffer)
{
    deFree(buffer->data);
    Buffer_init(buffer);
}

bool Buffer_resize(Buffer *buffer, size_t newSize)
{
    /* Grow buffer if necessary. */
    if (newSize > buffer->capacity)
    {
        size_t newCapacity = (size_t)deAlign32(deMax32(2 * (int)buffer->capacity, (int)newSize), 512);
        uint8_t *newData   = (uint8_t *)deMalloc(newCapacity);
        if (!newData)
            return false;

        if (buffer->data)
            memcpy(newData, buffer->data, buffer->size);

        deFree(buffer->data);
        buffer->data     = newData;
        buffer->capacity = newCapacity;
    }

    buffer->size = newSize;
    return true;
}

bool Buffer_append(Buffer *buffer, const uint8_t *data, size_t numBytes)
{
    size_t offset = buffer->size;

    if (!Buffer_resize(buffer, buffer->size + numBytes))
        return false;

    /* Append bytes. */
    memcpy(&buffer->data[offset], data, numBytes);
    return true;
}

#if defined(QP_SUPPORT_PNG)
void pngWriteData(png_structp png, png_bytep dataPtr, png_size_t numBytes)
{
    Buffer *buffer = (Buffer *)png_get_io_ptr(png);
    if (!Buffer_append(buffer, (const uint8_t *)dataPtr, numBytes))
        png_error(png, "unable to resize PNG write buffer!");
}

void pngFlushData(png_structp png)
{
    DE_UNREF(png);
    /* nada */
}

static bool writeCompressedPNG(png_structp png, png_infop info, png_byte **rowPointers, int width, int height,
                               int colorFormat)
{
    if (setjmp(png_jmpbuf(png)) == 0)
    {
        /* Write data. */
        png_set_IHDR(png, info, (png_uint_32)width, (png_uint_32)height, 8, colorFormat, PNG_INTERLACE_NONE,
                     PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
        png_write_info(png, info);
        png_write_image(png, rowPointers);
        png_write_end(png, NULL);

        return true;
    }
    else
        return false;
}

static bool compressImagePNG(Buffer *buffer, qpImageFormat imageFormat, int width, int height, int rowStride,
                             const void *data)
{
    bool compressOk        = false;
    png_structp png        = DE_NULL;
    png_infop info         = DE_NULL;
    png_byte **rowPointers = DE_NULL;
    bool hasAlpha          = imageFormat == QP_IMAGE_FORMAT_RGBA8888;
    int ndx;

    /* Handle format. */
    DE_ASSERT(imageFormat == QP_IMAGE_FORMAT_RGB888 || imageFormat == QP_IMAGE_FORMAT_RGBA8888);

    /* Allocate & set row pointers. */
    rowPointers = (png_byte **)deMalloc((size_t)height * sizeof(png_byte *));
    if (!rowPointers)
        return false;

    for (ndx = 0; ndx < height; ndx++)
        rowPointers[ndx] = (png_byte *)((const uint8_t *)data + ndx * rowStride);

    /* Initialize PNG compressor. */
    png  = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    info = png ? png_create_info_struct(png) : DE_NULL;
    if (png && info)
    {
        /* Set our own write function. */
        png_set_write_fn(png, buffer, pngWriteData, pngFlushData);

        compressOk = writeCompressedPNG(png, info, rowPointers, width, height,
                                        hasAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB);
    }

    /* Cleanup & return. */
    if (png && info)
    {
        png_destroy_info_struct(png, &info);
        png_destroy_write_struct(&png, DE_NULL);
    }
    else if (png)
        png_destroy_write_struct(&png, &info);

    deFree(rowPointers);
    return compressOk;
}
#endif /* QP_SUPPORT_PNG */

/*--------------------------------------------------------------------*//*!
 * \brief Start image set
 * \param log            qpTestLog instance
 * \param name            Unique identifier for the set
 * \param description    Human readable description
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_startImageSet(qpTestLog *log, const char *name, const char *description)
{
    qpXmlAttribute attribs[4];
    int numAttribs = 0;

    DE_ASSERT(log && name);
    deMutex_lock(log->lock);

    attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    if (description)
        attribs[numAttribs++] = qpSetStringAttrib("Description", description);

    /* <ImageSet Name="<name>"> */
    if (!qpXmlWriter_startElement(log->writer, "ImageSet", numAttribs, attribs))
    {
        qpPrintf("qpTestLog_startImageSet(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_IMAGESET));

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief End image set
 * \param log            qpTestLog instance
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_endImageSet(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    /* <ImageSet Name="<name>"> */
    if (!qpXmlWriter_endElement(log->writer, "ImageSet"))
    {
        qpPrintf("qpTestLog_endImageSet(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_IMAGESET);

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Write base64 encoded raw image data into log
 * \param log                qpTestLog instance
 * \param name                Unique name (matching names can be compared across BatchResults).
 * \param description        Textual description (shown in Candy).
 * \param compressionMode    Compression mode
 * \param imageFormat        Color format
 * \param width                Width in pixels
 * \param height            Height in pixels
 * \param stride            Data stride (offset between rows)
 * \param data                Pointer to pixel data
 * \return 0 if OK, otherwise <0
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeImage(qpTestLog *log, const char *name, const char *description,
                          qpImageCompressionMode compressionMode, qpImageFormat imageFormat, int width, int height,
                          int stride, const void *data)
{
    char widthStr[32];
    char heightStr[32];
    qpXmlAttribute attribs[8];
    int numAttribs = 0;
    Buffer compressedBuffer;
    const void *writeDataPtr = DE_NULL;
    size_t writeDataBytes    = ~(size_t)0;

    DE_ASSERT(log && name);
    DE_ASSERT(deInRange32(width, 1, 32768));
    DE_ASSERT(deInRange32(height, 1, 32768));
    DE_ASSERT(data);

    if (log->flags & QP_TEST_LOG_EXCLUDE_IMAGES)
        return true; /* Image not logged. */

    Buffer_init(&compressedBuffer);

    /* BEST compression mode defaults to PNG. */
    if (compressionMode == QP_IMAGE_COMPRESSION_MODE_BEST)
    {
#if defined(QP_SUPPORT_PNG)
        compressionMode = QP_IMAGE_COMPRESSION_MODE_PNG;
#else
        compressionMode = QP_IMAGE_COMPRESSION_MODE_NONE;
#endif
    }

#if defined(QP_SUPPORT_PNG)
    /* Try storing with PNG compression. */
    if (compressionMode == QP_IMAGE_COMPRESSION_MODE_PNG)
    {
        bool compressOk = compressImagePNG(&compressedBuffer, imageFormat, width, height, stride, data);
        if (compressOk)
        {
            writeDataPtr   = compressedBuffer.data;
            writeDataBytes = compressedBuffer.size;
        }
        else
        {
            /* Fall-back to default compression. */
            qpPrintf("WARNING: PNG compression failed -- storing image uncompressed.\n");
            compressionMode = QP_IMAGE_COMPRESSION_MODE_NONE;
        }
    }
#endif

    /* Handle image compression. */
    switch (compressionMode)
    {
    case QP_IMAGE_COMPRESSION_MODE_NONE:
    {
        int pixelSize    = imageFormat == QP_IMAGE_FORMAT_RGB888 ? 3 : 4;
        int packedStride = pixelSize * width;

        if (packedStride == stride)
            writeDataPtr = data;
        else
        {
            /* Need to re-pack pixels. */
            if (Buffer_resize(&compressedBuffer, (size_t)(packedStride * height)))
            {
                int row;
                for (row = 0; row < height; row++)
                    memcpy(&compressedBuffer.data[packedStride * row], &((const uint8_t *)data)[row * stride],
                           (size_t)(pixelSize * width));
            }
            else
            {
                qpPrintf("ERROR: Failed to pack pixels for writing.\n");
                Buffer_deinit(&compressedBuffer);
                return false;
            }
        }

        writeDataBytes = (size_t)(packedStride * height);
        break;
    }

#if defined(QP_SUPPORT_PNG)
    case QP_IMAGE_COMPRESSION_MODE_PNG:
        DE_ASSERT(writeDataPtr); /* Already handled. */
        break;
#endif

    default:
        qpPrintf("qpTestLog_writeImage(): Unknown compression mode: %s\n",
                 QP_LOOKUP_STRING(s_qpImageCompressionModeMap, compressionMode));
        Buffer_deinit(&compressedBuffer);
        return false;
    }

    /* Fill in attributes. */
    int32ToString(width, widthStr);
    int32ToString(height, heightStr);
    attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    attribs[numAttribs++] = qpSetStringAttrib("Width", widthStr);
    attribs[numAttribs++] = qpSetStringAttrib("Height", heightStr);
    attribs[numAttribs++] = qpSetStringAttrib("Format", QP_LOOKUP_STRING(s_qpImageFormatMap, imageFormat));
    attribs[numAttribs++] =
        qpSetStringAttrib("CompressionMode", QP_LOOKUP_STRING(s_qpImageCompressionModeMap, compressionMode));
    if (description)
        attribs[numAttribs++] = qpSetStringAttrib("Description", description);

    /* \note Log lock is acquired after compression! */
    deMutex_lock(log->lock);

    /* <Image ID="result" Name="Foobar" Width="640" Height="480" Format="RGB888" CompressionMode="None">base64 data</Image> */
    if (!qpXmlWriter_startElement(log->writer, "Image", numAttribs, attribs) ||
        !qpXmlWriter_writeBase64(log->writer, (const uint8_t *)writeDataPtr, writeDataBytes) ||
        !qpXmlWriter_endElement(log->writer, "Image"))
    {
        qpPrintf("qpTestLog_writeImage(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        Buffer_deinit(&compressedBuffer);
        return false;
    }

    deMutex_unlock(log->lock);

    /* Free compressed data if allocated. */
    Buffer_deinit(&compressedBuffer);

    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Writes infoLog into log. Might filter out empty infoLog.
 * \param log            qpTestLog instance
 * \param infoLog        Implementation provided shader compilation or linkage log
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeInfoLog(qpTestLog *log, const char *infoLog)
{
    if (infoLog == DE_NULL)
        return false;

    if (infoLog[0] == '\0' && (log->flags & QP_TEST_LOG_EXCLUDE_EMPTY_LOGINFO) != 0)
        return true;

    return qpXmlWriter_writeStringElement(log->writer, "InfoLog", infoLog);
}

/*--------------------------------------------------------------------*//*!
 * \brief Write a OpenGL ES shader program into the log.
 * \param linkOk            Shader program link result, false on failure
 * \param linkInfoLog        Implementation provided linkage log
 *//*--------------------------------------------------------------------*/
bool qpTestLog_startShaderProgram(qpTestLog *log, bool linkOk, const char *linkInfoLog)
{
    qpXmlAttribute programAttribs[4];
    int numProgramAttribs = 0;

    DE_ASSERT(log);
    deMutex_lock(log->lock);

    programAttribs[numProgramAttribs++] = qpSetStringAttrib("LinkStatus", linkOk ? "OK" : "Fail");

    if (!qpXmlWriter_startElement(log->writer, "ShaderProgram", numProgramAttribs, programAttribs) ||
        !qpTestLog_writeInfoLog(log, linkInfoLog))
    {
        qpPrintf("qpTestLog_startShaderProgram(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SHADERPROGRAM));

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief End shader program
 * \param log            qpTestLog instance
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_endShaderProgram(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    /* </ShaderProgram> */
    if (!qpXmlWriter_endElement(log->writer, "ShaderProgram"))
    {
        qpPrintf("qpTestLog_endShaderProgram(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SHADERPROGRAM);

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Write a OpenGL ES shader into the log.
 * \param type                Shader type
 * \param source            Shader source
 * \param compileOk            Shader compilation result, false on failure
 * \param infoLog            Implementation provided shader compilation log
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeShader(qpTestLog *log, qpShaderType type, const char *source, bool compileOk, const char *infoLog)
{
    const char *tagName   = QP_LOOKUP_STRING(s_qpShaderTypeMap, type);
    const char *sourceStr = ((log->flags & QP_TEST_LOG_EXCLUDE_SHADER_SOURCES) == 0 || !compileOk) ? source : "";
    int numShaderAttribs  = 0;
    qpXmlAttribute shaderAttribs[4];

    deMutex_lock(log->lock);

    DE_ASSERT(source);
    DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SHADERPROGRAM);

    shaderAttribs[numShaderAttribs++] = qpSetStringAttrib("CompileStatus", compileOk ? "OK" : "Fail");

    if (!qpXmlWriter_startElement(log->writer, tagName, numShaderAttribs, shaderAttribs) ||
        !qpXmlWriter_writeStringElement(log->writer, "ShaderSource", sourceStr) ||
        !qpTestLog_writeInfoLog(log, infoLog) || !qpXmlWriter_endElement(log->writer, tagName))
    {
        qpPrintf("qpTestLog_writeShader(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Start writing a set of EGL configurations into the log.
 *//*--------------------------------------------------------------------*/
bool qpTestLog_startEglConfigSet(qpTestLog *log, const char *name, const char *description)
{
    qpXmlAttribute attribs[4];
    int numAttribs = 0;

    DE_ASSERT(log && name);
    deMutex_lock(log->lock);

    attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    if (description)
        attribs[numAttribs++] = qpSetStringAttrib("Description", description);

    /* <EglConfigSet Name="<name>"> */
    if (!qpXmlWriter_startElement(log->writer, "EglConfigSet", numAttribs, attribs))
    {
        qpPrintf("qpTestLog_startEglImageSet(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_EGLCONFIGSET));

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief End an EGL config set
 *//*--------------------------------------------------------------------*/
bool qpTestLog_endEglConfigSet(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    /* <EglConfigSet Name="<name>"> */
    if (!qpXmlWriter_endElement(log->writer, "EglConfigSet"))
    {
        qpPrintf("qpTestLog_endEglImageSet(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_EGLCONFIGSET);

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Write an EGL config inside an EGL config set
 * \see   qpElgConfigInfo for details
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeEglConfig(qpTestLog *log, const qpEglConfigInfo *config)
{
    qpXmlAttribute attribs[64];
    int numAttribs = 0;

    DE_ASSERT(log && config);
    deMutex_lock(log->lock);

    attribs[numAttribs++] = qpSetIntAttrib("BufferSize", config->bufferSize);
    attribs[numAttribs++] = qpSetIntAttrib("RedSize", config->redSize);
    attribs[numAttribs++] = qpSetIntAttrib("GreenSize", config->greenSize);
    attribs[numAttribs++] = qpSetIntAttrib("BlueSize", config->blueSize);
    attribs[numAttribs++] = qpSetIntAttrib("LuminanceSize", config->luminanceSize);
    attribs[numAttribs++] = qpSetIntAttrib("AlphaSize", config->alphaSize);
    attribs[numAttribs++] = qpSetIntAttrib("AlphaMaskSize", config->alphaMaskSize);
    attribs[numAttribs++] = qpSetBoolAttrib("BindToTextureRGB", config->bindToTextureRGB);
    attribs[numAttribs++] = qpSetBoolAttrib("BindToTextureRGBA", config->bindToTextureRGBA);
    attribs[numAttribs++] = qpSetStringAttrib("ColorBufferType", config->colorBufferType);
    attribs[numAttribs++] = qpSetStringAttrib("ConfigCaveat", config->configCaveat);
    attribs[numAttribs++] = qpSetIntAttrib("ConfigID", config->configID);
    attribs[numAttribs++] = qpSetStringAttrib("Conformant", config->conformant);
    attribs[numAttribs++] = qpSetIntAttrib("DepthSize", config->depthSize);
    attribs[numAttribs++] = qpSetIntAttrib("Level", config->level);
    attribs[numAttribs++] = qpSetIntAttrib("MaxPBufferWidth", config->maxPBufferWidth);
    attribs[numAttribs++] = qpSetIntAttrib("MaxPBufferHeight", config->maxPBufferHeight);
    attribs[numAttribs++] = qpSetIntAttrib("MaxPBufferPixels", config->maxPBufferPixels);
    attribs[numAttribs++] = qpSetIntAttrib("MaxSwapInterval", config->maxSwapInterval);
    attribs[numAttribs++] = qpSetIntAttrib("MinSwapInterval", config->minSwapInterval);
    attribs[numAttribs++] = qpSetBoolAttrib("NativeRenderable", config->nativeRenderable);
    attribs[numAttribs++] = qpSetStringAttrib("RenderableType", config->renderableType);
    attribs[numAttribs++] = qpSetIntAttrib("SampleBuffers", config->sampleBuffers);
    attribs[numAttribs++] = qpSetIntAttrib("Samples", config->samples);
    attribs[numAttribs++] = qpSetIntAttrib("StencilSize", config->stencilSize);
    attribs[numAttribs++] = qpSetStringAttrib("SurfaceTypes", config->surfaceTypes);
    attribs[numAttribs++] = qpSetStringAttrib("TransparentType", config->transparentType);
    attribs[numAttribs++] = qpSetIntAttrib("TransparentRedValue", config->transparentRedValue);
    attribs[numAttribs++] = qpSetIntAttrib("TransparentGreenValue", config->transparentGreenValue);
    attribs[numAttribs++] = qpSetIntAttrib("TransparentBlueValue", config->transparentBlueValue);
    DE_ASSERT(numAttribs <= DE_LENGTH_OF_ARRAY(attribs));

    if (!qpXmlWriter_startElement(log->writer, "EglConfig", numAttribs, attribs) ||
        !qpXmlWriter_endElement(log->writer, "EglConfig"))
    {
        qpPrintf("qpTestLog_writeEglConfig(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Start section in log.
 * \param log            qpTestLog instance
 * \param name            Section name
 * \param description    Human readable description
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_startSection(qpTestLog *log, const char *name, const char *description)
{
    qpXmlAttribute attribs[2];
    int numAttribs = 0;

    DE_ASSERT(log && name);
    deMutex_lock(log->lock);

    attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    if (description)
        attribs[numAttribs++] = qpSetStringAttrib("Description", description);

    /* <Section Name="<name>" Description="<description>"> */
    if (!qpXmlWriter_startElement(log->writer, "Section", numAttribs, attribs))
    {
        qpPrintf("qpTestLog_startSection(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SECTION));

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief End section in log.
 * \param log            qpTestLog instance
 * \return true if ok, false otherwise
 *//*--------------------------------------------------------------------*/
bool qpTestLog_endSection(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    /* </Section> */
    if (!qpXmlWriter_endElement(log->writer, "Section"))
    {
        qpPrintf("qpTestLog_endSection(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SECTION);

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Write OpenCL compute kernel source into the log.
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeKernelSource(qpTestLog *log, const char *source)
{
    const char *sourceStr = (log->flags & QP_TEST_LOG_EXCLUDE_SHADER_SOURCES) != 0 ? "" : source;

    DE_ASSERT(log);
    deMutex_lock(log->lock);

    if (!qpXmlWriter_writeStringElement(log->writer, "KernelSource", sourceStr))
    {
        qpPrintf("qpTestLog_writeKernelSource(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Write a SPIR-V module assembly source into the log.
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeSpirVAssemblySource(qpTestLog *log, const char *source)
{
    const char *const sourceStr = (log->flags & QP_TEST_LOG_EXCLUDE_SHADER_SOURCES) != 0 ? "" : source;

    deMutex_lock(log->lock);

    DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SHADERPROGRAM);

    if (!qpXmlWriter_writeStringElement(log->writer, "SpirVAssemblySource", sourceStr))
    {
        qpPrintf("qpTestLog_writeSpirVAssemblySource(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

/*--------------------------------------------------------------------*//*!
 * \brief Write OpenCL kernel compilation results into the log
 *//*--------------------------------------------------------------------*/
bool qpTestLog_writeCompileInfo(qpTestLog *log, const char *name, const char *description, bool compileOk,
                                const char *infoLog)
{
    int numAttribs = 0;
    qpXmlAttribute attribs[3];

    DE_ASSERT(log && name && description && infoLog);
    deMutex_lock(log->lock);

    attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    attribs[numAttribs++] = qpSetStringAttrib("Description", description);
    attribs[numAttribs++] = qpSetStringAttrib("CompileStatus", compileOk ? "OK" : "Fail");

    if (!qpXmlWriter_startElement(log->writer, "CompileInfo", numAttribs, attribs) ||
        !qpTestLog_writeInfoLog(log, infoLog) || !qpXmlWriter_endElement(log->writer, "CompileInfo"))
    {
        qpPrintf("qpTestLog_writeCompileInfo(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_startSampleList(qpTestLog *log, const char *name, const char *description)
{
    int numAttribs = 0;
    qpXmlAttribute attribs[2];

    DE_ASSERT(log && name && description);
    deMutex_lock(log->lock);

    attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    attribs[numAttribs++] = qpSetStringAttrib("Description", description);

    if (!qpXmlWriter_startElement(log->writer, "SampleList", numAttribs, attribs))
    {
        qpPrintf("qpTestLog_startSampleList(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SAMPLELIST));

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_startSampleInfo(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    if (!qpXmlWriter_startElement(log->writer, "SampleInfo", 0, DE_NULL))
    {
        qpPrintf("qpTestLog_startSampleInfo(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SAMPLEINFO));

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_writeValueInfo(qpTestLog *log, const char *name, const char *description, const char *unit,
                              qpSampleValueTag tag)
{
    const char *tagName = QP_LOOKUP_STRING(s_qpSampleValueTagMap, tag);
    int numAttribs      = 0;
    qpXmlAttribute attribs[4];

    DE_ASSERT(log && name && description && tagName);
    deMutex_lock(log->lock);

    DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLEINFO);

    attribs[numAttribs++] = qpSetStringAttrib("Name", name);
    attribs[numAttribs++] = qpSetStringAttrib("Description", description);
    attribs[numAttribs++] = qpSetStringAttrib("Tag", tagName);

    if (unit)
        attribs[numAttribs++] = qpSetStringAttrib("Unit", unit);

    if (!qpXmlWriter_startElement(log->writer, "ValueInfo", numAttribs, attribs) ||
        !qpXmlWriter_endElement(log->writer, "ValueInfo"))
    {
        qpPrintf("qpTestLog_writeValueInfo(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_endSampleInfo(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    if (!qpXmlWriter_endElement(log->writer, "SampleInfo"))
    {
        qpPrintf("qpTestLog_endSampleInfo(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SAMPLEINFO);

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_startSample(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLELIST);

    if (!qpXmlWriter_startElement(log->writer, "Sample", 0, DE_NULL))
    {
        qpPrintf("qpTestLog_startSample(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SAMPLE));

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_writeValueFloat(qpTestLog *log, double value)
{
    char tmpString[512];
    doubleToString(value, tmpString, (int)sizeof(tmpString));

    deMutex_lock(log->lock);

    DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLE);

    if (!qpXmlWriter_writeStringElement(log->writer, "Value", &tmpString[0]))
    {
        qpPrintf("qpTestLog_writeSampleValue(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_writeValueInteger(qpTestLog *log, int64_t value)
{
    char tmpString[64];
    int64ToString(value, tmpString);

    deMutex_lock(log->lock);

    DE_ASSERT(ContainerStack_getTop(&log->containerStack) == CONTAINERTYPE_SAMPLE);

    if (!qpXmlWriter_writeStringElement(log->writer, "Value", &tmpString[0]))
    {
        qpPrintf("qpTestLog_writeSampleValue(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_endSample(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    if (!qpXmlWriter_endElement(log->writer, "Sample"))
    {
        qpPrintf("qpTestLog_endSample(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SAMPLE);

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_endSampleList(qpTestLog *log)
{
    DE_ASSERT(log);
    deMutex_lock(log->lock);

    if (!qpXmlWriter_endElement(log->writer, "SampleList"))
    {
        qpPrintf("qpTestLog_endSampleList(): Writing XML failed\n");
        deMutex_unlock(log->lock);
        return false;
    }

    DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SAMPLELIST);

    deMutex_unlock(log->lock);
    return true;
}

bool qpTestLog_writeRaw(qpTestLog *log, const char *rawContents)
{
    DE_ASSERT(log);

    fseek(log->outputFile, 0, SEEK_END);
    fprintf(log->outputFile, "%s", rawContents);
    if (!(log->flags & QP_TEST_LOG_NO_FLUSH))
        qpTestLog_flushFile(log);

    return true;
}

uint32_t qpTestLog_getLogFlags(const qpTestLog *log)
{
    DE_ASSERT(log);
    return log->flags;
}

const char *qpGetTestResultName(qpTestResult result)
{
    return QP_LOOKUP_STRING(s_qpTestResultMap, result);
}

bool qpTestLog_isCompact(qpTestLog *log)
{
    return (log->flags & QP_TEST_LOG_COMPACT) != 0;
}