executor/xeContainerFormatParser.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 log container format parser.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "xeContainerFormatParser.hpp"
  25 #include "deInt32.h"
  26
  27 namespace xe
  28 {
  29
  30 enum
  31 {
  32         CONTAINERFORMATPARSER_INITIAL_BUFFER_SIZE = 1024
  33 };
  34
  35 static int getNextBufferSize (int curSize, int minNewSize)
  36 {
  37         return de::max(curSize*2, 1<<deLog2Ceil32(minNewSize));
  38 }
  39
  40 ContainerFormatParser::ContainerFormatParser (void)
  41         : m_element             (CONTAINERELEMENT_INCOMPLETE)
  42         , m_elementLen  (0)
  43         , m_state               (STATE_AT_LINE_START)
  44         , m_buf                 (CONTAINERFORMATPARSER_INITIAL_BUFFER_SIZE)
  45 {
  46 }
  47
  48 ContainerFormatParser::~ContainerFormatParser (void)
  49 {
  50 }
  51
  52 void ContainerFormatParser::clear (void)
  53 {
  54         m_element               = CONTAINERELEMENT_INCOMPLETE;
  55         m_elementLen    = 0;
  56         m_state                 = STATE_AT_LINE_START;
  57         m_buf.clear();
  58 }
  59
  60 void ContainerFormatParser::error (const std::string& what)
  61 {
  62         throw ContainerParseError(what);
  63 }
  64
  65 void ContainerFormatParser::feed (const deUint8* bytes, size_t numBytes)
  66 {
  67         // Grow buffer if necessary.
  68         if (m_buf.getNumFree() < (int)numBytes)
  69                 m_buf.resize(getNextBufferSize(m_buf.getSize(), m_buf.getNumElements()+(int)numBytes));
  70
  71         // Append to front.
  72         m_buf.pushFront(bytes, (int)numBytes);
  73
  74         // If we haven't parsed complete element, re-try after data feed.
  75         if (m_element == CONTAINERELEMENT_INCOMPLETE)
  76                 advance();
  77 }
  78
  79 const char* ContainerFormatParser::getSessionInfoAttribute (void) const
  80 {
  81         DE_ASSERT(m_element == CONTAINERELEMENT_SESSION_INFO);
  82         return m_attribute.c_str();
  83 }
  84
  85 const char* ContainerFormatParser::getSessionInfoValue (void) const
  86 {
  87         DE_ASSERT(m_element == CONTAINERELEMENT_SESSION_INFO);
  88         return m_value.c_str();
  89 }
  90
  91 const char* ContainerFormatParser::getTestCasePath (void) const
  92 {
  93         DE_ASSERT(m_element == CONTAINERELEMENT_BEGIN_TEST_CASE_RESULT);
  94         return m_value.c_str();
  95 }
  96
  97 const char* ContainerFormatParser::getTerminateReason (void) const
  98 {
  99         DE_ASSERT(m_element == CONTAINERELEMENT_TERMINATE_TEST_CASE_RESULT);
 100         return m_value.c_str();
 101 }
 102
 103 int ContainerFormatParser::getDataSize (void) const
 104 {
 105         DE_ASSERT(m_element == CONTAINERELEMENT_TEST_LOG_DATA);
 106         return m_elementLen;
 107 }
 108
 109 void ContainerFormatParser::getData (deUint8* dst, int numBytes, int offset)
 110 {
 111         DE_ASSERT(de::inBounds(offset, 0, m_elementLen) && numBytes > 0 && de::inRange(numBytes+offset, 0, m_elementLen));
 112
 113         for (int ndx = 0; ndx < numBytes; ndx++)
 114                 dst[ndx] = m_buf.peekBack(offset+ndx);
 115 }
 116
 117 int ContainerFormatParser::getChar (int offset) const
 118 {
 119         DE_ASSERT(de::inRange(offset, 0, m_buf.getNumElements()));
 120
 121         if (offset < m_buf.getNumElements())
 122                 return m_buf.peekBack(offset);
 123         else
 124                 return END_OF_BUFFER;
 125 }
 126
 127 void ContainerFormatParser::advance (void)
 128 {
 129         if (m_element != CONTAINERELEMENT_INCOMPLETE)
 130         {
 131                 m_buf.popBack(m_elementLen);
 132
 133                 m_element               = CONTAINERELEMENT_INCOMPLETE;
 134                 m_elementLen    = 0;
 135                 m_attribute.clear();
 136                 m_value.clear();
 137         }
 138
 139         for (;;)
 140         {
 141                 int curChar = getChar(m_elementLen);
 142
 143                 if (curChar != (int)END_OF_BUFFER)
 144                         m_elementLen += 1;
 145
 146                 if (curChar == END_OF_STRING)
 147                 {
 148                         if (m_elementLen == 1)
 149                                 m_element = CONTAINERELEMENT_END_OF_STRING;
 150                         else if (m_state == STATE_CONTAINER_LINE)
 151                                 parseContainerLine();
 152                         else
 153                                 m_element = CONTAINERELEMENT_TEST_LOG_DATA;
 154
 155                         break;
 156                 }
 157                 else if (curChar == (int)END_OF_BUFFER)
 158                 {
 159                         if (m_elementLen > 0 && m_state == STATE_DATA)
 160                                 m_element = CONTAINERELEMENT_TEST_LOG_DATA;
 161
 162                         break;
 163                 }
 164                 else if (curChar == '\r' || curChar == '\n')
 165                 {
 166                         // Check for \r\n
 167                         int nextChar = getChar(m_elementLen);
 168                         if (curChar == '\n' || (nextChar != (int)END_OF_BUFFER && nextChar != '\n'))
 169                         {
 170                                 if (m_state == STATE_CONTAINER_LINE)
 171                                         parseContainerLine();
 172                                 else
 173                                         m_element = CONTAINERELEMENT_TEST_LOG_DATA;
 174
 175                                 m_state = STATE_AT_LINE_START;
 176                                 break;
 177                         }
 178                         // else handle following end or \n in next iteration.
 179                 }
 180                 else if (m_state == STATE_AT_LINE_START)
 181                 {
 182                         DE_ASSERT(m_elementLen == 1);
 183                         m_state = (curChar == '#') ? STATE_CONTAINER_LINE : STATE_DATA;
 184                 }
 185         }
 186 }
 187
 188 void ContainerFormatParser::parseContainerLine (void)
 189 {
 190         static const struct
 191         {
 192                 const char*                     name;
 193                 ContainerElement        element;
 194         } s_elements[] =
 195         {
 196                 { "beginTestCaseResult",                CONTAINERELEMENT_BEGIN_TEST_CASE_RESULT         },
 197                 { "endTestCaseResult",                  CONTAINERELEMENT_END_TEST_CASE_RESULT           },
 198                 { "terminateTestCaseResult",    CONTAINERELEMENT_TERMINATE_TEST_CASE_RESULT     },
 199                 { "sessionInfo",                                CONTAINERELEMENT_SESSION_INFO                           },
 200                 { "beginSession",                               CONTAINERELEMENT_BEGIN_SESSION                          },
 201                 { "endSession",                                 CONTAINERELEMENT_END_SESSION                            }
 202         };
 203
 204         DE_ASSERT(m_elementLen >= 1);
 205         DE_ASSERT(getChar(0) == '#');
 206
 207         int offset = 1;
 208
 209         for (int elemNdx = 0; elemNdx < DE_LENGTH_OF_ARRAY(s_elements); elemNdx++)
 210         {
 211                 bool    isMatch = false;
 212                 int             ndx             = 0;
 213
 214                 for (;;)
 215                 {
 216                         int             bufChar         = (offset+ndx < m_elementLen) ? getChar(offset+ndx) : 0;
 217                         bool    bufEnd          = bufChar == 0 || bufChar == ' ' || bufChar == '\r' || bufChar == '\n' || bufChar == (int)END_OF_BUFFER;
 218                         int             elemChar        = s_elements[elemNdx].name[ndx];
 219                         bool    elemEnd         = elemChar == 0;
 220
 221                         if (bufEnd || elemEnd)
 222                         {
 223                                 isMatch = bufEnd == elemEnd;
 224                                 break;
 225                         }
 226                         else if (bufChar != elemChar)
 227                                 break;
 228
 229                         ndx += 1;
 230                 }
 231
 232                 if (isMatch)
 233                 {
 234                         m_element        = s_elements[elemNdx].element;
 235                         offset          += ndx;
 236                         break;
 237                 }
 238         }
 239
 240         switch (m_element)
 241         {
 242                 case CONTAINERELEMENT_BEGIN_SESSION:
 243                 case CONTAINERELEMENT_END_SESSION:
 244                 case CONTAINERELEMENT_END_TEST_CASE_RESULT:
 245                         break; // No attribute or value.
 246
 247                 case CONTAINERELEMENT_BEGIN_TEST_CASE_RESULT:
 248                 case CONTAINERELEMENT_TERMINATE_TEST_CASE_RESULT:
 249                         if (getChar(offset) != ' ')
 250                                 error("Expected value after instruction");
 251                         offset += 1;
 252                         parseContainerValue(m_value, offset);
 253                         break;
 254
 255                 case CONTAINERELEMENT_SESSION_INFO:
 256                         if (getChar(offset) != ' ')
 257                                 error("Expected attribute name after #sessionInfo");
 258                         offset += 1;
 259                         parseContainerValue(m_attribute, offset);
 260                         if (getChar(offset) != ' ')
 261                                 error("No value for #sessionInfo attribute");
 262                         offset += 1;
 263
 264                         if (m_attribute == "timestamp")
 265                         {
 266                                 m_value.clear();
 267
 268                                 // \note Candy produces timestamps in very stupid fashion.
 269                                 for (;;)
 270                                 {
 271                                         const int       curChar = offset < m_elementLen ? getChar(offset) : 0;
 272                                         const bool      isEnd   = curChar == 0 || curChar == (int)END_OF_BUFFER || curChar == '\n' || curChar == '\t';
 273
 274                                         if (isEnd)
 275                                                 break;
 276                                         else
 277                                                 m_value.push_back((char)curChar);
 278
 279                                         offset += 1;
 280                                 }
 281                         }
 282                         else
 283                                 parseContainerValue(m_value, offset);
 284                         break;
 285
 286                 default:
 287                         // \todo [2012-06-09 pyry] Implement better way to handle # at the beginning of log lines.
 288                         m_element = CONTAINERELEMENT_TEST_LOG_DATA;
 289                         break;
 290         }
 291 }
 292
 293 void ContainerFormatParser::parseContainerValue (std::string& dst, int& offset) const
 294 {
 295         DE_ASSERT(offset < m_elementLen);
 296
 297         bool    isString        = getChar(offset) == '"' || getChar(offset) == '\'';
 298         int             quotChar        = isString ? getChar(offset) : 0;
 299
 300         if (isString)
 301                 offset += 1;
 302
 303         dst.clear();
 304
 305         for (;;)
 306         {
 307                 int             curChar         = offset < m_elementLen ? getChar(offset) : 0;
 308                 bool    isEnd           = curChar == 0 || curChar == (int)END_OF_BUFFER ||
 309                                                           (isString ? (curChar == quotChar) : (curChar == ' ' || curChar == '\n' || curChar == '\r'));
 310
 311                 if (isEnd)
 312                         break;
 313                 else
 314                 {
 315                         // \todo [2012-06-09 pyry] Escapes.
 316                         dst.push_back((char)curChar);
 317                 }
 318
 319                 offset += 1;
 320         }
 321
 322         if (isString && getChar(offset) == quotChar)
 323                 offset += 1;
 324 }
 325
 326 } // xe