/*------------------------------------------------------------------------- * 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 #endif #include #include #include #if (DE_OS == DE_OS_WIN32) #include #include #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 details * */ 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 */ 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); /* 15 */ 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)); /* 15 */ 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); /* */ 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); /* */ 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); /* base64 data */ 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); /* */ 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); /* */ 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); /* */ 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); /*
*/ 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); /*
*/ 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; }