Use -Wno-error=date-time am: 865f9aae63 am: 5b7e673b0c
[platform/upstream/VK-GL-CTS.git] / executor / xeTestResultParser.cpp
1 /*-------------------------------------------------------------------------
2  * drawElements Quality Program Test Executor
3  * ------------------------------------------
4  *
5  * Copyright 2014 The Android Open Source Project
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *//*!
20  * \file
21  * \brief Test case result parser.
22  *//*--------------------------------------------------------------------*/
23
24 #include "xeTestResultParser.hpp"
25 #include "xeTestCaseResult.hpp"
26 #include "xeBatchResult.hpp"
27 #include "deString.h"
28 #include "deInt32.h"
29
30 #include <sstream>
31 #include <stdlib.h>
32
33 using std::string;
34 using std::vector;
35
36 namespace xe
37 {
38
39 static inline int toInt (const char* str)
40 {
41         return atoi(str);
42 }
43
44 static inline double toDouble (const char* str)
45 {
46         return atof(str);
47 }
48
49 static inline deInt64 toInt64 (const char* str)
50 {
51         std::istringstream      s       (str);
52         deInt64                         val;
53
54         s >> val;
55
56         return val;
57 }
58
59 static inline bool toBool (const char* str)
60 {
61         return deStringEqual(str, "OK") || deStringEqual(str, "True");
62 }
63
64 static const char* stripLeadingWhitespace (const char* str)
65 {
66         int whitespaceCount = 0;
67
68         while (str[whitespaceCount]     != 0    &&
69                    (str[whitespaceCount] == ' '         ||
70                         str[whitespaceCount] == '\t'    ||
71                         str[whitespaceCount] == '\r'    ||
72                         str[whitespaceCount] == '\n'))
73                 whitespaceCount += 1;
74
75         return str + whitespaceCount;
76 }
77
78 struct EnumMapEntry
79 {
80         deUint32                hash;
81         const char*             name;
82         int                             value;
83 };
84
85 static const EnumMapEntry s_statusCodeMap[] =
86 {
87         { 0x7c8a99bc,   "Pass",                                 TESTSTATUSCODE_PASS                                             },
88         { 0x7c851ca1,   "Fail",                                 TESTSTATUSCODE_FAIL                                             },
89         { 0x10ecd324,   "QualityWarning",               TESTSTATUSCODE_QUALITY_WARNING                  },
90         { 0x341ae835,   "CompatibilityWarning", TESTSTATUSCODE_COMPATIBILITY_WARNING    },
91         { 0x058acbca,   "Pending",                              TESTSTATUSCODE_PENDING                                  },
92         { 0xc4d74b26,   "Running",                              TESTSTATUSCODE_RUNNING                                  },
93         { 0x6409f93c,   "NotSupported",                 TESTSTATUSCODE_NOT_SUPPORTED                    },
94         { 0xfa5a9ab7,   "ResourceError",                TESTSTATUSCODE_RESOURCE_ERROR                   },
95         { 0xad6793ec,   "InternalError",                TESTSTATUSCODE_INTERNAL_ERROR                   },
96         { 0x838f3034,   "Canceled",                             TESTSTATUSCODE_CANCELED                                 },
97         { 0x42b6efac,   "Timeout",                              TESTSTATUSCODE_TIMEOUT                                  },
98         { 0x0cfb98f6,   "Crash",                                TESTSTATUSCODE_CRASH                                    },
99         { 0xe326e01d,   "Disabled",                             TESTSTATUSCODE_DISABLED                                 },
100         { 0x77061af2,   "Terminated",                   TESTSTATUSCODE_TERMINATED                               }
101 };
102
103 static const EnumMapEntry s_resultItemMap[] =
104 {
105         { 0xce8ac2e4,   "Result",                               ri::TYPE_RESULT                 },
106         { 0x7c8cdcea,   "Text",                                 ri::TYPE_TEXT                   },
107         { 0xc6540c6e,   "Number",                               ri::TYPE_NUMBER                 },
108         { 0x0d656c88,   "Image",                                ri::TYPE_IMAGE                  },
109         { 0x8ac9ee14,   "ImageSet",                             ri::TYPE_IMAGESET               },
110         { 0x1181fa5a,   "VertexShader",                 ri::TYPE_SHADER                 },
111         { 0xa93daef0,   "FragmentShader",               ri::TYPE_SHADER                 },
112         { 0x8f066128,   "GeometryShader",               ri::TYPE_SHADER                 },
113         { 0x235a931c,   "TessControlShader",    ri::TYPE_SHADER                 },
114         { 0xa1bf7153,   "TessEvaluationShader", ri::TYPE_SHADER                 },
115         { 0x6c1415d9,   "ComputeShader",                ri::TYPE_SHADER                 },
116         { 0x72863a54,   "ShaderProgram",                ri::TYPE_SHADERPROGRAM  },
117         { 0xb4efc08d,   "ShaderSource",                 ri::TYPE_SHADERSOURCE   },
118         { 0xff265913,   "InfoLog",                              ri::TYPE_INFOLOG                },
119         { 0x84159b73,   "EglConfig",                    ri::TYPE_EGLCONFIG              },
120         { 0xdd34391f,   "EglConfigSet",                 ri::TYPE_EGLCONFIGSET   },
121         { 0xebbb3aba,   "Section",                              ri::TYPE_SECTION                },
122         { 0xa0f15677,   "KernelSource",                 ri::TYPE_KERNELSOURCE   },
123         { 0x1ee9083a,   "CompileInfo",                  ri::TYPE_COMPILEINFO    },
124         { 0xf1004023,   "SampleList",                   ri::TYPE_SAMPLELIST             },
125         { 0xf0feae93,   "SampleInfo",                   ri::TYPE_SAMPLEINFO             },
126         { 0x2aa6f14e,   "ValueInfo",                    ri::TYPE_VALUEINFO              },
127         { 0xd09429e7,   "Sample",                               ri::TYPE_SAMPLE                 },
128         { 0x0e4a4722,   "Value",                                ri::TYPE_SAMPLEVALUE    },
129 };
130
131 static const EnumMapEntry s_imageFormatMap[] =
132 {
133         { 0xcc4ffac8,   "RGB888",               ri::Image::FORMAT_RGB888        },
134         { 0x20dcb0c1,   "RGBA8888",             ri::Image::FORMAT_RGBA8888      }
135 };
136
137 static const EnumMapEntry s_compressionMap[] =
138 {
139         { 0x7c89bbd5,   "None",                 ri::Image::COMPRESSION_NONE     },
140         { 0x0b88118a,   "PNG",                  ri::Image::COMPRESSION_PNG      }
141 };
142
143 static const EnumMapEntry s_shaderTypeFromTagMap[] =
144 {
145         { 0x1181fa5a,   "VertexShader",                 ri::Shader::SHADERTYPE_VERTEX                   },
146         { 0xa93daef0,   "FragmentShader",               ri::Shader::SHADERTYPE_FRAGMENT                 },
147         { 0x8f066128,   "GeometryShader",               ri::Shader::SHADERTYPE_GEOMETRY                 },
148         { 0x235a931c,   "TessControlShader",    ri::Shader::SHADERTYPE_TESS_CONTROL             },
149         { 0xa1bf7153,   "TessEvaluationShader", ri::Shader::SHADERTYPE_TESS_EVALUATION  },
150         { 0x6c1415d9,   "ComputeShader",                ri::Shader::SHADERTYPE_COMPUTE                  },
151 };
152
153 static const EnumMapEntry s_testTypeMap[] =
154 {
155         { 0x7fa80959,   "SelfValidate", TESTCASETYPE_SELF_VALIDATE      },
156         { 0xdb797567,   "Capability",   TESTCASETYPE_CAPABILITY         },
157         { 0x2ca3ec10,   "Accuracy",             TESTCASETYPE_ACCURACY           },
158         { 0xa48ac277,   "Performance",  TESTCASETYPE_PERFORMANCE        }
159 };
160
161 static const EnumMapEntry s_logVersionMap[] =
162 {
163         { 0x0b7dac93,   "0.2.0",                TESTLOGVERSION_0_2_0    },
164         { 0x0b7db0d4,   "0.3.0",                TESTLOGVERSION_0_3_0    },
165         { 0x0b7db0d5,   "0.3.1",                TESTLOGVERSION_0_3_1    },
166         { 0x0b7db0d6,   "0.3.2",                TESTLOGVERSION_0_3_2    },
167         { 0x0b7db0d7,   "0.3.3",                TESTLOGVERSION_0_3_3    }
168 };
169
170 static const EnumMapEntry s_sampleValueTagMap[] =
171 {
172         { 0xddf2d0d1,   "Predictor",    ri::ValueInfo::VALUETAG_PREDICTOR       },
173         { 0x9bee2c34,   "Response",             ri::ValueInfo::VALUETAG_RESPONSE        },
174 };
175
176 #if defined(DE_DEBUG)
177 static void printHashes (const char* name, const EnumMapEntry* entries, int numEntries)
178 {
179         printf("%s:\n", name);
180
181         for (int ndx = 0; ndx < numEntries; ndx++)
182                 printf("0x%08x\t%s\n", deStringHash(entries[ndx].name), entries[ndx].name);
183
184         printf("\n");
185 }
186
187 #define PRINT_HASHES(MAP) printHashes(#MAP, MAP, DE_LENGTH_OF_ARRAY(MAP))
188
189 void TestResultParser_printHashes (void)
190 {
191         PRINT_HASHES(s_statusCodeMap);
192         PRINT_HASHES(s_resultItemMap);
193         PRINT_HASHES(s_imageFormatMap);
194         PRINT_HASHES(s_compressionMap);
195         PRINT_HASHES(s_shaderTypeFromTagMap);
196         PRINT_HASHES(s_testTypeMap);
197         PRINT_HASHES(s_logVersionMap);
198         PRINT_HASHES(s_sampleValueTagMap);
199 }
200 #endif
201
202 static inline int getEnumValue (const char* enumName, const EnumMapEntry* entries, int numEntries, const char* name)
203 {
204         deUint32 hash = deStringHash(name);
205
206         for (int ndx = 0; ndx < numEntries; ndx++)
207         {
208                 if (entries[ndx].hash == hash && deStringEqual(entries[ndx].name, name))
209                         return entries[ndx].value;
210         }
211
212         throw TestResultParseError(string("Could not map '") + name + "' to " + enumName);
213 }
214
215 TestStatusCode getTestStatusCode (const char* statusCode)
216 {
217         return (TestStatusCode)getEnumValue("status code", s_statusCodeMap, DE_LENGTH_OF_ARRAY(s_statusCodeMap), statusCode);
218 }
219
220 static ri::Type getResultItemType (const char* elemName)
221 {
222         return (ri::Type)getEnumValue("result item type", s_resultItemMap, DE_LENGTH_OF_ARRAY(s_resultItemMap), elemName);
223 }
224
225 static ri::Image::Format getImageFormat (const char* imageFormat)
226 {
227         return (ri::Image::Format)getEnumValue("image format", s_imageFormatMap, DE_LENGTH_OF_ARRAY(s_imageFormatMap), imageFormat);
228 }
229
230 static ri::Image::Compression getImageCompression (const char* compression)
231 {
232         return (ri::Image::Compression)getEnumValue("image compression", s_compressionMap, DE_LENGTH_OF_ARRAY(s_compressionMap), compression);
233 }
234
235 static ri::Shader::ShaderType getShaderTypeFromTagName (const char* shaderType)
236 {
237         return (ri::Shader::ShaderType)getEnumValue("shader type", s_shaderTypeFromTagMap, DE_LENGTH_OF_ARRAY(s_shaderTypeFromTagMap), shaderType);
238 }
239
240 static TestCaseType getTestCaseType (const char* caseType)
241 {
242         return (TestCaseType)getEnumValue("test case type", s_testTypeMap, DE_LENGTH_OF_ARRAY(s_testTypeMap), caseType);
243 }
244
245 static TestLogVersion getTestLogVersion (const char* logVersion)
246 {
247         return (TestLogVersion)getEnumValue("test log version", s_logVersionMap, DE_LENGTH_OF_ARRAY(s_logVersionMap), logVersion);
248 }
249
250 static ri::ValueInfo::ValueTag getSampleValueTag (const char* tag)
251 {
252         return (ri::ValueInfo::ValueTag)getEnumValue("sample value tag", s_sampleValueTagMap, DE_LENGTH_OF_ARRAY(s_sampleValueTagMap), tag);
253 }
254
255 static TestCaseType getTestCaseTypeFromPath (const char* casePath)
256 {
257         if (deStringBeginsWith(casePath, "dEQP-GLES2."))
258         {
259                 const char* group = casePath+11;
260                 if (deStringBeginsWith(group, "capability."))
261                         return TESTCASETYPE_CAPABILITY;
262                 else if (deStringBeginsWith(group, "accuracy."))
263                         return TESTCASETYPE_ACCURACY;
264                 else if (deStringBeginsWith(group, "performance."))
265                         return TESTCASETYPE_PERFORMANCE;
266         }
267
268         return TESTCASETYPE_SELF_VALIDATE;
269 }
270
271 static ri::NumericValue getNumericValue (const std::string& value)
272 {
273         const bool      isFloat         = value.find('.') != std::string::npos || value.find('e') != std::string::npos;
274
275         if (isFloat)
276         {
277                 const double num = toDouble(stripLeadingWhitespace(value.c_str()));
278                 return ri::NumericValue(num);
279         }
280         else
281         {
282                 const deInt64 num = toInt64(stripLeadingWhitespace(value.c_str()));
283                 return ri::NumericValue(num);
284         }
285 }
286
287 TestResultParser::TestResultParser (void)
288         : m_result                              (DE_NULL)
289         , m_state                               (STATE_NOT_INITIALIZED)
290         , m_logVersion                  (TESTLOGVERSION_LAST)
291         , m_curItemList                 (DE_NULL)
292         , m_base64DecodeOffset  (0)
293 {
294 }
295
296 TestResultParser::~TestResultParser (void)
297 {
298 }
299
300 void TestResultParser::clear (void)
301 {
302         m_xmlParser.clear();
303         m_itemStack.clear();
304
305         m_result                                = DE_NULL;
306         m_state                                 = STATE_NOT_INITIALIZED;
307         m_logVersion                    = TESTLOGVERSION_LAST;
308         m_curItemList                   = DE_NULL;
309         m_base64DecodeOffset    = 0;
310         m_curNumValue.clear();
311 }
312
313 void TestResultParser::init (TestCaseResult* dstResult)
314 {
315         clear();
316         m_result                = dstResult;
317         m_state                 = STATE_INITIALIZED;
318         m_curItemList   = &dstResult->resultItems;
319 }
320
321 TestResultParser::ParseResult TestResultParser::parse (const deUint8* bytes, int numBytes)
322 {
323         DE_ASSERT(m_result && m_state != STATE_NOT_INITIALIZED);
324
325         try
326         {
327                 bool resultChanged = false;
328
329                 m_xmlParser.feed(bytes, numBytes);
330
331                 for (;;)
332                 {
333                         xml::Element curElement = m_xmlParser.getElement();
334
335                         if (curElement == xml::ELEMENT_INCOMPLETE       ||
336                                 curElement == xml::ELEMENT_END_OF_STRING)
337                                 break;
338
339                         switch (curElement)
340                         {
341                                 case xml::ELEMENT_START:        handleElementStart();           break;
342                                 case xml::ELEMENT_END:          handleElementEnd();                     break;
343                                 case xml::ELEMENT_DATA:         handleData();                           break;
344
345                                 default:
346                                         DE_ASSERT(false);
347                         }
348
349                         resultChanged = true;
350                         m_xmlParser.advance();
351                 }
352
353                 if (m_xmlParser.getElement() == xml::ELEMENT_END_OF_STRING)
354                 {
355                         if (m_state != STATE_TEST_CASE_RESULT_ENDED)
356                                 throw TestResultParseError("Unexpected end of log data");
357
358                         return PARSERESULT_COMPLETE;
359                 }
360                 else
361                         return resultChanged ? PARSERESULT_CHANGED
362                                                                  : PARSERESULT_NOT_CHANGED;
363         }
364         catch (const TestResultParseError& e)
365         {
366                 // Set error code to result.
367                 m_result->statusCode    = TESTSTATUSCODE_INTERNAL_ERROR;
368                 m_result->statusDetails = e.what();
369
370                 return PARSERESULT_ERROR;
371         }
372         catch (const xml::ParseError& e)
373         {
374                 // Set error code to result.
375                 m_result->statusCode    = TESTSTATUSCODE_INTERNAL_ERROR;
376                 m_result->statusDetails = e.what();
377
378                 return PARSERESULT_ERROR;
379         }
380 }
381
382 const char* TestResultParser::getAttribute (const char* name)
383 {
384         if (!m_xmlParser.hasAttribute(name))
385                 throw TestResultParseError(string("Missing attribute '") + name + "' in <" + m_xmlParser.getElementName() + ">");
386
387         return m_xmlParser.getAttribute(name);
388 }
389
390 ri::Item* TestResultParser::getCurrentItem (void)
391 {
392         return !m_itemStack.empty() ? m_itemStack.back() : DE_NULL;
393 }
394
395 ri::List* TestResultParser::getCurrentItemList (void)
396 {
397         DE_ASSERT(m_curItemList);
398         return m_curItemList;
399 }
400
401 void TestResultParser::updateCurrentItemList (void)
402 {
403         m_curItemList = DE_NULL;
404
405         for (vector<ri::Item*>::reverse_iterator i = m_itemStack.rbegin(); i != m_itemStack.rend(); i++)
406         {
407                 ri::Item*       item    = *i;
408                 ri::Type        type    = item->getType();
409
410                 if (type == ri::TYPE_IMAGESET)
411                         m_curItemList = &static_cast<ri::ImageSet*>(item)->images;
412                 else if (type == ri::TYPE_SECTION)
413                         m_curItemList = &static_cast<ri::Section*>(item)->items;
414                 else if (type == ri::TYPE_EGLCONFIGSET)
415                         m_curItemList = &static_cast<ri::EglConfigSet*>(item)->configs;
416                 else if (type == ri::TYPE_SHADERPROGRAM)
417                         m_curItemList = &static_cast<ri::ShaderProgram*>(item)->shaders;
418
419                 if (m_curItemList)
420                         break;
421         }
422
423         if (!m_curItemList)
424                 m_curItemList = &m_result->resultItems;
425 }
426
427 void TestResultParser::pushItem (ri::Item* item)
428 {
429         m_itemStack.push_back(item);
430         updateCurrentItemList();
431 }
432
433 void TestResultParser::popItem (void)
434 {
435         m_itemStack.pop_back();
436         updateCurrentItemList();
437 }
438
439 void TestResultParser::handleElementStart (void)
440 {
441         const char* elemName = m_xmlParser.getElementName();
442
443         if (m_state == STATE_INITIALIZED)
444         {
445                 // Expect TestCaseResult.
446                 if (!deStringEqual(elemName, "TestCaseResult"))
447                         throw TestResultParseError(string("Expected <TestCaseResult>, got <") + elemName + ">");
448
449                 const char* version = getAttribute("Version");
450                 m_logVersion = getTestLogVersion(version);
451                 // \note Currently assumed that all known log versions are supported.
452
453                 m_result->casePath      = getAttribute("CasePath");
454                 m_result->caseType      = TESTCASETYPE_SELF_VALIDATE;
455
456                 if (m_xmlParser.hasAttribute("CaseType"))
457                         m_result->caseType = getTestCaseType(m_xmlParser.getAttribute("CaseType"));
458                 else
459                 {
460                         // Do guess based on path for legacy log files.
461                         if (m_logVersion >= TESTLOGVERSION_0_3_2)
462                                 throw TestResultParseError("Missing CaseType attribute in <TestCaseResult>");
463                         m_result->caseType = getTestCaseTypeFromPath(m_result->casePath.c_str());
464                 }
465
466                 m_state = STATE_IN_TEST_CASE_RESULT;
467         }
468         else
469         {
470                 ri::List*       curList         = getCurrentItemList();
471                 ri::Type        itemType        = getResultItemType(elemName);
472                 ri::Item*       item            = DE_NULL;
473                 ri::Item*       parentItem      = getCurrentItem();
474                 ri::Type        parentType      = parentItem ? parentItem->getType() : ri::TYPE_LAST;
475
476                 switch (itemType)
477                 {
478                         case ri::TYPE_RESULT:
479                         {
480                                 ri::Result* result = curList->allocItem<ri::Result>();
481                                 result->statusCode = getTestStatusCode(getAttribute("StatusCode"));
482                                 item = result;
483                                 break;
484                         }
485
486                         case ri::TYPE_TEXT:
487                                 item = curList->allocItem<ri::Text>();
488                                 break;
489
490                         case ri::TYPE_SECTION:
491                         {
492                                 ri::Section* section = curList->allocItem<ri::Section>();
493                                 section->name                   = getAttribute("Name");
494                                 section->description    = getAttribute("Description");
495                                 item = section;
496                                 break;
497                         }
498
499                         case ri::TYPE_NUMBER:
500                         {
501                                 ri::Number* number = curList->allocItem<ri::Number>();
502                                 number->name            = getAttribute("Name");
503                                 number->description     = getAttribute("Description");
504                                 number->unit            = getAttribute("Unit");
505
506                                 if (m_xmlParser.hasAttribute("Tag"))
507                                         number->tag = m_xmlParser.getAttribute("Tag");
508
509                                 item = number;
510
511                                 m_curNumValue.clear();
512                                 break;
513                         }
514
515                         case ri::TYPE_IMAGESET:
516                         {
517                                 ri::ImageSet* imageSet = curList->allocItem<ri::ImageSet>();
518                                 imageSet->name                  = getAttribute("Name");
519                                 imageSet->description   = getAttribute("Description");
520                                 item = imageSet;
521                                 break;
522                         }
523
524                         case ri::TYPE_IMAGE:
525                         {
526                                 ri::Image* image = curList->allocItem<ri::Image>();
527                                 image->name                     = getAttribute("Name");
528                                 image->description      = getAttribute("Description");
529                                 image->width            = toInt(getAttribute("Width"));
530                                 image->height           = toInt(getAttribute("Height"));
531                                 image->format           = getImageFormat(getAttribute("Format"));
532                                 image->compression      = getImageCompression(getAttribute("CompressionMode"));
533                                 item = image;
534                                 break;
535                         }
536
537                         case ri::TYPE_SHADERPROGRAM:
538                         {
539                                 ri::ShaderProgram* shaderProgram = curList->allocItem<ri::ShaderProgram>();
540                                 shaderProgram->linkStatus = toBool(getAttribute("LinkStatus"));
541                                 item = shaderProgram;
542                                 break;
543                         }
544
545                         case ri::TYPE_SHADER:
546                         {
547                                 if (parentType != ri::TYPE_SHADERPROGRAM)
548                                         throw TestResultParseError("<VertexShader> outside of <ShaderProgram>");
549
550                                 ri::Shader* shader = curList->allocItem<ri::Shader>();
551
552                                 shader->shaderType              = getShaderTypeFromTagName(elemName);
553                                 shader->compileStatus   = toBool(getAttribute("CompileStatus"));
554
555                                 item = shader;
556                                 break;
557                         }
558
559                         case ri::TYPE_SHADERSOURCE:
560                                 if (parentType == ri::TYPE_SHADER)
561                                         item = &static_cast<ri::Shader*>(parentItem)->source;
562                                 else
563                                         throw TestResultParseError("Unexpected <ShaderSource>");
564                                 break;
565
566                         case ri::TYPE_INFOLOG:
567                                 if (parentType == ri::TYPE_SHADERPROGRAM)
568                                         item = &static_cast<ri::ShaderProgram*>(parentItem)->linkInfoLog;
569                                 else if (parentType == ri::TYPE_SHADER)
570                                         item = &static_cast<ri::Shader*>(parentItem)->infoLog;
571                                 else if (parentType == ri::TYPE_COMPILEINFO)
572                                         item = &static_cast<ri::CompileInfo*>(parentItem)->infoLog;
573                                 else
574                                         throw TestResultParseError("Unexpected <InfoLog>");
575                                 break;
576
577                         case ri::TYPE_KERNELSOURCE:
578                                 item = curList->allocItem<ri::KernelSource>();
579                                 break;
580
581                         case ri::TYPE_COMPILEINFO:
582                         {
583                                 ri::CompileInfo* info = curList->allocItem<ri::CompileInfo>();
584                                 info->name                      = getAttribute("Name");
585                                 info->description       = getAttribute("Description");
586                                 info->compileStatus     = toBool(getAttribute("CompileStatus"));
587                                 item = info;
588                                 break;
589                         }
590
591                         case ri::TYPE_EGLCONFIGSET:
592                         {
593                                 ri::EglConfigSet* set = curList->allocItem<ri::EglConfigSet>();
594                                 set->name                       = getAttribute("Name");
595                                 set->description        = m_xmlParser.hasAttribute("Description") ? m_xmlParser.getAttribute("Description") : "";
596                                 item = set;
597                                 break;
598                         }
599
600                         case ri::TYPE_EGLCONFIG:
601                         {
602                                 ri::EglConfig* config = curList->allocItem<ri::EglConfig>();
603                                 config->bufferSize                              = toInt(getAttribute("BufferSize"));
604                                 config->redSize                                 = toInt(getAttribute("RedSize"));
605                                 config->greenSize                               = toInt(getAttribute("GreenSize"));
606                                 config->blueSize                                = toInt(getAttribute("BlueSize"));
607                                 config->luminanceSize                   = toInt(getAttribute("LuminanceSize"));
608                                 config->alphaSize                               = toInt(getAttribute("AlphaSize"));
609                                 config->alphaMaskSize                   = toInt(getAttribute("AlphaMaskSize"));
610                                 config->bindToTextureRGB                = toBool(getAttribute("BindToTextureRGB"));
611                                 config->bindToTextureRGBA               = toBool(getAttribute("BindToTextureRGBA"));
612                                 config->colorBufferType                 = getAttribute("ColorBufferType");
613                                 config->configCaveat                    = getAttribute("ConfigCaveat");
614                                 config->configID                                = toInt(getAttribute("ConfigID"));
615                                 config->conformant                              = getAttribute("Conformant");
616                                 config->depthSize                               = toInt(getAttribute("DepthSize"));
617                                 config->level                                   = toInt(getAttribute("Level"));
618                                 config->maxPBufferWidth                 = toInt(getAttribute("MaxPBufferWidth"));
619                                 config->maxPBufferHeight                = toInt(getAttribute("MaxPBufferHeight"));
620                                 config->maxPBufferPixels                = toInt(getAttribute("MaxPBufferPixels"));
621                                 config->maxSwapInterval                 = toInt(getAttribute("MaxSwapInterval"));
622                                 config->minSwapInterval                 = toInt(getAttribute("MinSwapInterval"));
623                                 config->nativeRenderable                = toBool(getAttribute("NativeRenderable"));
624                                 config->renderableType                  = getAttribute("RenderableType");
625                                 config->sampleBuffers                   = toInt(getAttribute("SampleBuffers"));
626                                 config->samples                                 = toInt(getAttribute("Samples"));
627                                 config->stencilSize                             = toInt(getAttribute("StencilSize"));
628                                 config->surfaceTypes                    = getAttribute("SurfaceTypes");
629                                 config->transparentType                 = getAttribute("TransparentType");
630                                 config->transparentRedValue             = toInt(getAttribute("TransparentRedValue"));
631                                 config->transparentGreenValue   = toInt(getAttribute("TransparentGreenValue"));
632                                 config->transparentBlueValue    = toInt(getAttribute("TransparentBlueValue"));
633                                 item = config;
634                                 break;
635                         }
636
637                         case ri::TYPE_SAMPLELIST:
638                         {
639                                 ri::SampleList* list = curList->allocItem<ri::SampleList>();
640                                 list->name                      = getAttribute("Name");
641                                 list->description       = getAttribute("Description");
642                                 item = list;
643                                 break;
644                         }
645
646                         case ri::TYPE_SAMPLEINFO:
647                         {
648                                 if (parentType != ri::TYPE_SAMPLELIST)
649                                         throw TestResultParseError("<SampleInfo> outside of <SampleList>");
650
651                                 ri::SampleList* list    = static_cast<ri::SampleList*>(parentItem);
652                                 ri::SampleInfo* info    = &list->sampleInfo;
653
654                                 item = info;
655                                 break;
656                         }
657
658                         case ri::TYPE_VALUEINFO:
659                         {
660                                 if (parentType != ri::TYPE_SAMPLEINFO)
661                                         throw TestResultParseError("<ValueInfo> outside of <SampleInfo>");
662
663                                 ri::SampleInfo* sampleInfo      = static_cast<ri::SampleInfo*>(parentItem);
664                                 ri::ValueInfo*  valueInfo       = sampleInfo->valueInfos.allocItem<ri::ValueInfo>();
665
666                                 valueInfo->name                 = getAttribute("Name");
667                                 valueInfo->description  = getAttribute("Description");
668                                 valueInfo->tag                  = getSampleValueTag(getAttribute("Tag"));
669
670                                 if (m_xmlParser.hasAttribute("Unit"))
671                                         valueInfo->unit = getAttribute("Unit");
672
673                                 item = valueInfo;
674                                 break;
675                         }
676
677                         case ri::TYPE_SAMPLE:
678                         {
679                                 if (parentType != ri::TYPE_SAMPLELIST)
680                                         throw TestResultParseError("<Sample> outside of <SampleList>");
681
682                                 ri::SampleList* list    = static_cast<ri::SampleList*>(parentItem);
683                                 ri::Sample*             sample  = list->samples.allocItem<ri::Sample>();
684
685                                 item = sample;
686                                 break;
687                         }
688
689                         case ri::TYPE_SAMPLEVALUE:
690                         {
691                                 if (parentType != ri::TYPE_SAMPLE)
692                                         throw TestResultParseError("<Value> outside of <Sample>");
693
694                                 ri::Sample*                     sample  = static_cast<ri::Sample*>(parentItem);
695                                 ri::SampleValue*        value   = sample->values.allocItem<ri::SampleValue>();
696
697                                 item = value;
698                                 break;
699                         }
700
701                         default:
702                                 throw TestResultParseError(string("Unsupported element '") + elemName + ("'"));
703                 }
704
705                 DE_ASSERT(item);
706                 pushItem(item);
707
708                 // Reset base64 decoding offset.
709                 m_base64DecodeOffset = 0;
710         }
711 }
712
713 void TestResultParser::handleElementEnd (void)
714 {
715         const char* elemName = m_xmlParser.getElementName();
716
717         if (m_state != STATE_IN_TEST_CASE_RESULT)
718                 throw TestResultParseError(string("Unexpected </") + elemName + "> outside of <TestCaseResult>");
719
720         if (deStringEqual(elemName, "TestCaseResult"))
721         {
722                 // Logs from buggy test cases may contain invalid XML.
723                 // DE_ASSERT(getCurrentItem() == DE_NULL);
724                 // \todo [2012-11-22 pyry] Log warning.
725
726                 m_state = STATE_TEST_CASE_RESULT_ENDED;
727         }
728         else
729         {
730                 ri::Type        itemType        = getResultItemType(elemName);
731                 ri::Item*       curItem         = getCurrentItem();
732
733                 if (!curItem || itemType != curItem->getType())
734                         throw TestResultParseError(string("Unexpected </") + elemName + ">");
735
736                 if (itemType == ri::TYPE_RESULT)
737                 {
738                         ri::Result* result = static_cast<ri::Result*>(curItem);
739                         m_result->statusCode    = result->statusCode;
740                         m_result->statusDetails = result->details;
741                 }
742                 else if (itemType == ri::TYPE_NUMBER)
743                 {
744                         // Parse value for number.
745                         ri::Number*     number  = static_cast<ri::Number*>(curItem);
746                         number->value = getNumericValue(m_curNumValue);
747                         m_curNumValue.clear();
748                 }
749                 else if (itemType == ri::TYPE_SAMPLEVALUE)
750                 {
751                         ri::SampleValue* value = static_cast<ri::SampleValue*>(curItem);
752                         value->value = getNumericValue(m_curNumValue);
753                         m_curNumValue.clear();
754                 }
755
756                 popItem();
757         }
758 }
759
760 void TestResultParser::handleData (void)
761 {
762         ri::Item*       curItem         = getCurrentItem();
763         ri::Type        type            = curItem ? curItem->getType() : ri::TYPE_LAST;
764
765         switch (type)
766         {
767                 case ri::TYPE_RESULT:
768                         m_xmlParser.appendDataStr(static_cast<ri::Result*>(curItem)->details);
769                         break;
770
771                 case ri::TYPE_TEXT:
772                         m_xmlParser.appendDataStr(static_cast<ri::Text*>(curItem)->text);
773                         break;
774
775                 case ri::TYPE_SHADERSOURCE:
776                         m_xmlParser.appendDataStr(static_cast<ri::ShaderSource*>(curItem)->source);
777                         break;
778
779                 case ri::TYPE_INFOLOG:
780                         m_xmlParser.appendDataStr(static_cast<ri::InfoLog*>(curItem)->log);
781                         break;
782
783                 case ri::TYPE_KERNELSOURCE:
784                         m_xmlParser.appendDataStr(static_cast<ri::KernelSource*>(curItem)->source);
785                         break;
786
787                 case ri::TYPE_NUMBER:
788                 case ri::TYPE_SAMPLEVALUE:
789                         m_xmlParser.appendDataStr(m_curNumValue);
790                         break;
791
792                 case ri::TYPE_IMAGE:
793                 {
794                         ri::Image* image = static_cast<ri::Image*>(curItem);
795
796                         // Base64 decode.
797                         int numBytesIn = m_xmlParser.getDataSize();
798
799                         for (int inNdx = 0; inNdx < numBytesIn; inNdx++)
800                         {
801                                 deUint8         byte            = m_xmlParser.getDataByte(inNdx);
802                                 deUint8         decodedBits     = 0;
803
804                                 if (de::inRange<deInt8>(byte, 'A', 'Z'))
805                                         decodedBits = (deUint8)(byte - 'A');
806                                 else if (de::inRange<deInt8>(byte, 'a', 'z'))
807                                         decodedBits = (deUint8)(('Z'-'A'+1) + (byte-'a'));
808                                 else if (de::inRange<deInt8>(byte, '0', '9'))
809                                         decodedBits = (deUint8)(('Z'-'A'+1) + ('z'-'a'+1) + (byte-'0'));
810                                 else if (byte == '+')
811                                         decodedBits = ('Z'-'A'+1) + ('z'-'a'+1) + ('9'-'0'+1);
812                                 else if (byte == '/')
813                                         decodedBits = ('Z'-'A'+1) + ('z'-'a'+1) + ('9'-'0'+2);
814                                 else if (byte == '=')
815                                 {
816                                         // Padding at end - remove last byte.
817                                         if (image->data.empty())
818                                                 throw TestResultParseError("Malformed base64 data");
819                                         image->data.pop_back();
820                                         continue;
821                                 }
822                                 else
823                                         continue; // Not an B64 input character.
824
825                                 int phase = m_base64DecodeOffset % 4;
826
827                                 if (phase == 0)
828                                         image->data.resize(image->data.size()+3, 0);
829
830                                 if ((int)image->data.size() < (m_base64DecodeOffset>>2)*3 + 3)
831                                         throw TestResultParseError("Malformed base64 data");
832                                 deUint8* outPtr = &image->data[(m_base64DecodeOffset>>2)*3];
833
834                                 switch (phase)
835                                 {
836                                         case 0: outPtr[0] |= (deUint8)(decodedBits<<2);                                                                                                 break;
837                                         case 1: outPtr[0] |= (deUint8)(decodedBits>>4); outPtr[1] |= (deUint8)((decodedBits&0xF)<<4);   break;
838                                         case 2: outPtr[1] |= (deUint8)(decodedBits>>2); outPtr[2] |= (deUint8)((decodedBits&0x3)<<6);   break;
839                                         case 3: outPtr[2] |= decodedBits;                                                                                                                               break;
840                                         default:
841                                                 DE_ASSERT(false);
842                                 }
843
844                                 m_base64DecodeOffset += 1;
845                         }
846
847                         break;
848                 }
849
850                 default:
851                         // Just ignore data.
852                         break;
853         }
854 }
855
856 //! Helper for parsing TestCaseResult from TestCaseResultData.
857 void parseTestCaseResultFromData (TestResultParser* parser, TestCaseResult* result, const TestCaseResultData& data)
858 {
859         DE_ASSERT(result->resultItems.getNumItems() == 0);
860
861         // Initialize status codes etc. from data.
862         result->casePath                = data.getTestCasePath();
863         result->caseType                = TESTCASETYPE_SELF_VALIDATE;
864         result->statusCode              = data.getStatusCode();
865         result->statusDetails   = data.getStatusDetails();
866
867         if (data.getDataSize() > 0)
868         {
869                 parser->init(result);
870
871                 const TestResultParser::ParseResult parseResult = parser->parse(data.getData(), data.getDataSize());
872
873                 if (result->statusCode == TESTSTATUSCODE_LAST)
874                 {
875                         result->statusCode = TESTSTATUSCODE_INTERNAL_ERROR;
876
877                         if (parseResult == TestResultParser::PARSERESULT_ERROR)
878                                 result->statusDetails = "Test case result parsing failed";
879                         else if (parseResult != TestResultParser::PARSERESULT_COMPLETE)
880                                 result->statusDetails = "Incomplete test case result";
881                         else
882                                 result->statusDetails = "Test case result is missing <Result> item";
883                 }
884         }
885         else if (result->statusCode == TESTSTATUSCODE_LAST)
886         {
887                 result->statusCode              = TESTSTATUSCODE_TERMINATED;
888                 result->statusDetails   = "Empty test case result";
889         }
890
891         if (result->casePath.empty())
892                 throw Error("Empty test case path in result");
893
894         if (result->caseType == TESTCASETYPE_LAST)
895                 throw Error("Invalid test case type in result");
896
897         DE_ASSERT(result->statusCode != TESTSTATUSCODE_LAST);
898 }
899
900 } // xe