| /*------------------------------------------------------------------------- |
| * drawElements Quality Program Test Executor |
| * ------------------------------------------ |
| * |
| * 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 log writer. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "xeTestLogWriter.hpp" |
| #include "xeXMLWriter.hpp" |
| #include "deStringUtil.hpp" |
| |
| #include <fstream> |
| |
| namespace xe |
| { |
| |
| /* Batch result writer. */ |
| |
| struct ContainerValue |
| { |
| ContainerValue(const std::string &value_) : value(value_) |
| { |
| } |
| ContainerValue(const char *value_) : value(value_) |
| { |
| } |
| std::string value; |
| }; |
| |
| std::ostream &operator<<(std::ostream &stream, const ContainerValue &value) |
| { |
| if (value.value.find(' ') != std::string::npos) |
| { |
| // Escape. |
| stream << '"'; |
| for (std::string::const_iterator i = value.value.begin(); i != value.value.end(); i++) |
| { |
| if (*i == '"' || *i == '\\') |
| stream << '\\'; |
| stream << *i; |
| } |
| stream << '"'; |
| } |
| else |
| stream << value.value; |
| |
| return stream; |
| } |
| |
| static void writeSessionInfo(const SessionInfo &info, std::ostream &stream) |
| { |
| if (!info.releaseName.empty()) |
| stream << "#sessionInfo releaseName " << ContainerValue(info.releaseName) << "\n"; |
| |
| if (!info.releaseId.empty()) |
| stream << "#sessionInfo releaseId " << ContainerValue(info.releaseId) << "\n"; |
| |
| if (!info.targetName.empty()) |
| stream << "#sessionInfo targetName " << ContainerValue(info.targetName) << "\n"; |
| |
| if (!info.candyTargetName.empty()) |
| stream << "#sessionInfo candyTargetName " << ContainerValue(info.candyTargetName) << "\n"; |
| |
| if (!info.configName.empty()) |
| stream << "#sessionInfo configName " << ContainerValue(info.configName) << "\n"; |
| |
| if (!info.resultName.empty()) |
| stream << "#sessionInfo resultName " << ContainerValue(info.resultName) << "\n"; |
| |
| // \note Current format uses unescaped timestamps for some strange reason. |
| if (!info.timestamp.empty()) |
| stream << "#sessionInfo timestamp " << info.timestamp << "\n"; |
| } |
| |
| static void writeTestCase(const TestCaseResultData &caseData, std::ostream &stream) |
| { |
| stream << "\n#beginTestCaseResult " << caseData.getTestCasePath() << "\n"; |
| |
| if (caseData.getDataSize() > 0) |
| { |
| stream.write((const char *)caseData.getData(), caseData.getDataSize()); |
| |
| uint8_t lastCh = caseData.getData()[caseData.getDataSize() - 1]; |
| if (lastCh != '\n' && lastCh != '\r') |
| stream << "\n"; |
| } |
| |
| TestStatusCode dataCode = caseData.getStatusCode(); |
| if (dataCode == TESTSTATUSCODE_CRASH || dataCode == TESTSTATUSCODE_TIMEOUT || dataCode == TESTSTATUSCODE_TERMINATED) |
| stream << "#terminateTestCaseResult " << getTestStatusCodeName(dataCode) << "\n"; |
| else |
| stream << "#endTestCaseResult\n"; |
| } |
| |
| void writeTestLog(const BatchResult &result, std::ostream &stream) |
| { |
| writeSessionInfo(result.getSessionInfo(), stream); |
| |
| stream << "#beginSession\n"; |
| |
| for (int ndx = 0; ndx < result.getNumTestCaseResults(); ndx++) |
| { |
| ConstTestCaseResultPtr caseData = result.getTestCaseResult(ndx); |
| writeTestCase(*caseData, stream); |
| } |
| |
| stream << "\n#endSession\n"; |
| } |
| |
| void writeBatchResultToFile(const BatchResult &result, const char *filename) |
| { |
| std::ofstream str(filename, std::ofstream::binary | std::ofstream::trunc); |
| writeTestLog(result, str); |
| str.close(); |
| } |
| |
| /* Test result log writer. */ |
| |
| static const char *getImageFormatName(ri::Image::Format format) |
| { |
| switch (format) |
| { |
| case ri::Image::FORMAT_RGB888: |
| return "RGB888"; |
| case ri::Image::FORMAT_RGBA8888: |
| return "RGBA8888"; |
| default: |
| DE_ASSERT(false); |
| return nullptr; |
| } |
| } |
| |
| static const char *getImageCompressionName(ri::Image::Compression compression) |
| { |
| switch (compression) |
| { |
| case ri::Image::COMPRESSION_NONE: |
| return "None"; |
| case ri::Image::COMPRESSION_PNG: |
| return "PNG"; |
| default: |
| DE_ASSERT(false); |
| return nullptr; |
| } |
| } |
| |
| static const char *getSampleValueTagName(ri::ValueInfo::ValueTag tag) |
| { |
| switch (tag) |
| { |
| case ri::ValueInfo::VALUETAG_PREDICTOR: |
| return "Predictor"; |
| case ri::ValueInfo::VALUETAG_RESPONSE: |
| return "Response"; |
| default: |
| DE_ASSERT(false); |
| return nullptr; |
| } |
| } |
| |
| inline const char *getBoolName(bool val) |
| { |
| return val ? "True" : "False"; |
| } |
| |
| // \todo [2012-09-07 pyry] Move to tcutil? |
| class Base64Formatter |
| { |
| public: |
| const uint8_t *data; |
| int numBytes; |
| |
| Base64Formatter(const uint8_t *data_, int numBytes_) : data(data_), numBytes(numBytes_) |
| { |
| } |
| }; |
| |
| std::ostream &operator<<(std::ostream &str, const Base64Formatter &fmt) |
| { |
| static const char s_base64Table[64] = { |
| 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', |
| 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', |
| 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'}; |
| |
| const uint8_t *data = fmt.data; |
| int numBytes = fmt.numBytes; |
| int srcNdx = 0; |
| |
| DE_ASSERT(data && (numBytes > 0)); |
| |
| /* Loop all input chars. */ |
| while (srcNdx < numBytes) |
| { |
| int numRead = de::min(3, numBytes - srcNdx); |
| uint8_t s0 = data[srcNdx]; |
| uint8_t s1 = (numRead >= 2) ? data[srcNdx + 1] : 0; |
| uint8_t s2 = (numRead >= 3) ? data[srcNdx + 2] : 0; |
| char d[4]; |
| |
| srcNdx += numRead; |
| |
| d[0] = s_base64Table[s0 >> 2]; |
| d[1] = s_base64Table[((s0 & 0x3) << 4) | (s1 >> 4)]; |
| d[2] = s_base64Table[((s1 & 0xF) << 2) | (s2 >> 6)]; |
| d[3] = s_base64Table[s2 & 0x3F]; |
| |
| if (numRead < 3) |
| d[3] = '='; |
| if (numRead < 2) |
| d[2] = '='; |
| |
| /* Write data. */ |
| str.write(&d[0], sizeof(d)); |
| } |
| |
| return str; |
| } |
| |
| inline Base64Formatter toBase64(const uint8_t *bytes, int numBytes) |
| { |
| return Base64Formatter(bytes, numBytes); |
| } |
| |
| static const char *getStatusName(bool value) |
| { |
| return value ? "OK" : "Fail"; |
| } |
| |
| static void writeResultItem(const ri::Item &item, xml::Writer &dst) |
| { |
| using xml::Writer; |
| |
| switch (item.getType()) |
| { |
| case ri::TYPE_RESULT: |
| // Ignored here, written at end. |
| break; |
| |
| case ri::TYPE_TEXT: |
| dst << Writer::BeginElement("Text") << static_cast<const ri::Text &>(item).text << Writer::EndElement; |
| break; |
| |
| case ri::TYPE_NUMBER: |
| { |
| const ri::Number &number = static_cast<const ri::Number &>(item); |
| dst << Writer::BeginElement("Number") << Writer::Attribute("Name", number.name) |
| << Writer::Attribute("Description", number.description) << Writer::Attribute("Unit", number.unit) |
| << Writer::Attribute("Tag", number.tag) << number.value << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_IMAGE: |
| { |
| const ri::Image &image = static_cast<const ri::Image &>(item); |
| dst << Writer::BeginElement("Image") << Writer::Attribute("Name", image.name) |
| << Writer::Attribute("Description", image.description) |
| << Writer::Attribute("Width", de::toString(image.width)) |
| << Writer::Attribute("Height", de::toString(image.height)) |
| << Writer::Attribute("Format", getImageFormatName(image.format)) |
| << Writer::Attribute("CompressionMode", getImageCompressionName(image.compression)) |
| << toBase64(&image.data[0], (int)image.data.size()) << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_IMAGESET: |
| { |
| const ri::ImageSet &imageSet = static_cast<const ri::ImageSet &>(item); |
| dst << Writer::BeginElement("ImageSet") << Writer::Attribute("Name", imageSet.name) |
| << Writer::Attribute("Description", imageSet.description); |
| |
| for (int ndx = 0; ndx < imageSet.images.getNumItems(); ndx++) |
| writeResultItem(imageSet.images.getItem(ndx), dst); |
| |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_SHADER: |
| { |
| const ri::Shader &shader = static_cast<const ri::Shader &>(item); |
| const char *tagName = nullptr; |
| |
| switch (shader.shaderType) |
| { |
| case ri::Shader::SHADERTYPE_VERTEX: |
| tagName = "VertexShader"; |
| break; |
| case ri::Shader::SHADERTYPE_FRAGMENT: |
| tagName = "FragmentShader"; |
| break; |
| case ri::Shader::SHADERTYPE_GEOMETRY: |
| tagName = "GeometryShader"; |
| break; |
| case ri::Shader::SHADERTYPE_TESS_CONTROL: |
| tagName = "TessControlShader"; |
| break; |
| case ri::Shader::SHADERTYPE_TESS_EVALUATION: |
| tagName = "TessEvaluationShader"; |
| break; |
| case ri::Shader::SHADERTYPE_COMPUTE: |
| tagName = "ComputeShader"; |
| break; |
| case ri::Shader::SHADERTYPE_RAYGEN: |
| tagName = "RaygenShader"; |
| break; |
| case ri::Shader::SHADERTYPE_ANY_HIT: |
| tagName = "AnyHitShader"; |
| break; |
| case ri::Shader::SHADERTYPE_CLOSEST_HIT: |
| tagName = "ClosestHitShader"; |
| break; |
| case ri::Shader::SHADERTYPE_MISS: |
| tagName = "MissShader"; |
| break; |
| case ri::Shader::SHADERTYPE_INTERSECTION: |
| tagName = "IntersectionShader"; |
| break; |
| case ri::Shader::SHADERTYPE_CALLABLE: |
| tagName = "CallableShader"; |
| break; |
| case ri::Shader::SHADERTYPE_TASK: |
| tagName = "TaskShader"; |
| break; |
| case ri::Shader::SHADERTYPE_MESH: |
| tagName = "MeshShader"; |
| break; |
| |
| default: |
| throw Error("Unknown shader type"); |
| } |
| |
| dst << Writer::BeginElement(tagName) << Writer::Attribute("CompileStatus", getStatusName(shader.compileStatus)); |
| |
| writeResultItem(shader.source, dst); |
| writeResultItem(shader.infoLog, dst); |
| |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_SHADERPROGRAM: |
| { |
| const ri::ShaderProgram &program = static_cast<const ri::ShaderProgram &>(item); |
| dst << Writer::BeginElement("ShaderProgram") |
| << Writer::Attribute("LinkStatus", getStatusName(program.linkStatus)); |
| |
| writeResultItem(program.linkInfoLog, dst); |
| |
| for (int ndx = 0; ndx < program.shaders.getNumItems(); ndx++) |
| writeResultItem(program.shaders.getItem(ndx), dst); |
| |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_SHADERSOURCE: |
| dst << Writer::BeginElement("ShaderSource") << static_cast<const ri::ShaderSource &>(item).source |
| << Writer::EndElement; |
| break; |
| |
| case ri::TYPE_SPIRVSOURCE: |
| dst << Writer::BeginElement("SpirVAssemblySource") << static_cast<const ri::SpirVSource &>(item).source |
| << Writer::EndElement; |
| break; |
| |
| case ri::TYPE_INFOLOG: |
| dst << Writer::BeginElement("InfoLog") << static_cast<const ri::InfoLog &>(item).log << Writer::EndElement; |
| break; |
| |
| case ri::TYPE_SECTION: |
| { |
| const ri::Section §ion = static_cast<const ri::Section &>(item); |
| dst << Writer::BeginElement("Section") << Writer::Attribute("Name", section.name) |
| << Writer::Attribute("Description", section.description); |
| |
| for (int ndx = 0; ndx < section.items.getNumItems(); ndx++) |
| writeResultItem(section.items.getItem(ndx), dst); |
| |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_KERNELSOURCE: |
| dst << Writer::BeginElement("KernelSource") << static_cast<const ri::KernelSource &>(item).source |
| << Writer::EndElement; |
| break; |
| |
| case ri::TYPE_COMPILEINFO: |
| { |
| const ri::CompileInfo &compileInfo = static_cast<const ri::CompileInfo &>(item); |
| dst << Writer::BeginElement("CompileInfo") << Writer::Attribute("Name", compileInfo.name) |
| << Writer::Attribute("Description", compileInfo.description) |
| << Writer::Attribute("CompileStatus", getStatusName(compileInfo.compileStatus)); |
| |
| writeResultItem(compileInfo.infoLog, dst); |
| |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_EGLCONFIG: |
| { |
| const ri::EglConfig &config = static_cast<const ri::EglConfig &>(item); |
| dst << Writer::BeginElement("EglConfig") << Writer::Attribute("BufferSize", de::toString(config.bufferSize)) |
| << Writer::Attribute("RedSize", de::toString(config.redSize)) |
| << Writer::Attribute("GreenSize", de::toString(config.greenSize)) |
| << Writer::Attribute("BlueSize", de::toString(config.blueSize)) |
| << Writer::Attribute("LuminanceSize", de::toString(config.luminanceSize)) |
| << Writer::Attribute("AlphaSize", de::toString(config.alphaSize)) |
| << Writer::Attribute("AlphaMaskSize", de::toString(config.alphaMaskSize)) |
| << Writer::Attribute("BindToTextureRGB", getBoolName(config.bindToTextureRGB)) |
| << Writer::Attribute("BindToTextureRGBA", getBoolName(config.bindToTextureRGBA)) |
| << Writer::Attribute("ColorBufferType", config.colorBufferType) |
| << Writer::Attribute("ConfigCaveat", config.configCaveat) |
| << Writer::Attribute("ConfigID", de::toString(config.configID)) |
| << Writer::Attribute("Conformant", config.conformant) |
| << Writer::Attribute("DepthSize", de::toString(config.depthSize)) |
| << Writer::Attribute("Level", de::toString(config.level)) |
| << Writer::Attribute("MaxPBufferWidth", de::toString(config.maxPBufferWidth)) |
| << Writer::Attribute("MaxPBufferHeight", de::toString(config.maxPBufferHeight)) |
| << Writer::Attribute("MaxPBufferPixels", de::toString(config.maxPBufferPixels)) |
| << Writer::Attribute("MaxSwapInterval", de::toString(config.maxSwapInterval)) |
| << Writer::Attribute("MinSwapInterval", de::toString(config.minSwapInterval)) |
| << Writer::Attribute("NativeRenderable", getBoolName(config.nativeRenderable)) |
| << Writer::Attribute("RenderableType", config.renderableType) |
| << Writer::Attribute("SampleBuffers", de::toString(config.sampleBuffers)) |
| << Writer::Attribute("Samples", de::toString(config.samples)) |
| << Writer::Attribute("StencilSize", de::toString(config.stencilSize)) |
| << Writer::Attribute("SurfaceTypes", config.surfaceTypes) |
| << Writer::Attribute("TransparentType", config.transparentType) |
| << Writer::Attribute("TransparentRedValue", de::toString(config.transparentRedValue)) |
| << Writer::Attribute("TransparentGreenValue", de::toString(config.transparentGreenValue)) |
| << Writer::Attribute("TransparentBlueValue", de::toString(config.transparentBlueValue)) |
| << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_EGLCONFIGSET: |
| { |
| const ri::EglConfigSet &configSet = static_cast<const ri::EglConfigSet &>(item); |
| dst << Writer::BeginElement("EglConfigSet") << Writer::Attribute("Name", configSet.name) |
| << Writer::Attribute("Description", configSet.description); |
| |
| for (int ndx = 0; ndx < configSet.configs.getNumItems(); ndx++) |
| writeResultItem(configSet.configs.getItem(ndx), dst); |
| |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_SAMPLELIST: |
| { |
| const ri::SampleList &list = static_cast<const ri::SampleList &>(item); |
| dst << Writer::BeginElement("SampleList") << Writer::Attribute("Name", list.name) |
| << Writer::Attribute("Description", list.description); |
| |
| writeResultItem(list.sampleInfo, dst); |
| |
| for (int ndx = 0; ndx < list.samples.getNumItems(); ndx++) |
| writeResultItem(list.samples.getItem(ndx), dst); |
| |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_SAMPLEINFO: |
| { |
| const ri::SampleInfo &info = static_cast<const ri::SampleInfo &>(item); |
| dst << Writer::BeginElement("SampleInfo"); |
| for (int ndx = 0; ndx < info.valueInfos.getNumItems(); ndx++) |
| writeResultItem(info.valueInfos.getItem(ndx), dst); |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_VALUEINFO: |
| { |
| const ri::ValueInfo &info = static_cast<const ri::ValueInfo &>(item); |
| dst << Writer::BeginElement("ValueInfo") << Writer::Attribute("Name", info.name) |
| << Writer::Attribute("Description", info.description) |
| << Writer::Attribute("Tag", getSampleValueTagName(info.tag)); |
| if (!info.unit.empty()) |
| dst << Writer::Attribute("Unit", info.unit); |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_SAMPLE: |
| { |
| const ri::Sample &sample = static_cast<const ri::Sample &>(item); |
| dst << Writer::BeginElement("Sample"); |
| for (int ndx = 0; ndx < sample.values.getNumItems(); ndx++) |
| writeResultItem(sample.values.getItem(ndx), dst); |
| dst << Writer::EndElement; |
| break; |
| } |
| |
| case ri::TYPE_SAMPLEVALUE: |
| { |
| const ri::SampleValue &value = static_cast<const ri::SampleValue &>(item); |
| dst << Writer::BeginElement("Value") << value.value << Writer::EndElement; |
| break; |
| } |
| |
| default: |
| XE_FAIL("Unsupported result item"); |
| } |
| } |
| |
| void writeTestResult(const TestCaseResult &result, xe::xml::Writer &xmlWriter) |
| { |
| using xml::Writer; |
| |
| xmlWriter << Writer::BeginElement("TestCaseResult") << Writer::Attribute("Version", result.caseVersion) |
| << Writer::Attribute("CasePath", result.casePath) |
| << Writer::Attribute("CaseType", getTestCaseTypeName(result.caseType)); |
| |
| for (int ndx = 0; ndx < result.resultItems.getNumItems(); ndx++) |
| writeResultItem(result.resultItems.getItem(ndx), xmlWriter); |
| |
| // Result item is not logged until end. |
| xmlWriter << Writer::BeginElement("Result") |
| << Writer::Attribute("StatusCode", getTestStatusCodeName(result.statusCode)) << result.statusDetails |
| << Writer::EndElement; |
| |
| xmlWriter << Writer::EndElement; |
| } |
| |
| void writeTestResult(const TestCaseResult &result, std::ostream &stream) |
| { |
| xml::Writer xmlWriter(stream); |
| stream << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; |
| writeTestResult(result, xmlWriter); |
| } |
| |
| void writeTestResultToFile(const TestCaseResult &result, const char *filename) |
| { |
| std::ofstream str(filename, std::ofstream::binary | std::ofstream::trunc); |
| writeTestResult(result, str); |
| str.close(); |
| } |
| |
| } // namespace xe |
