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 Extract values by name from logs. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "xeTestLogParser.hpp" 25 #include "xeTestResultParser.hpp" 26 #include "deFilePath.hpp" 27 #include "deString.h" 28 29 #include <vector> 30 #include <string> 31 #include <cstdio> 32 #include <cstdlib> 33 #include <fstream> 34 #include <iostream> 35 #include <stdexcept> 36 37 using std::vector; 38 using std::string; 39 using std::set; 40 using std::map; 41 42 struct CommandLine 43 { 44 CommandLine (void) 45 : statusCode(false) 46 { 47 } 48 49 string filename; 50 vector<string> tagNames; 51 bool statusCode; 52 }; 53 54 typedef xe::ri::NumericValue Value; 55 56 struct CaseValues 57 { 58 string casePath; 59 xe::TestCaseType caseType; 60 xe::TestStatusCode statusCode; 61 string statusDetails; 62 63 vector<Value> values; 64 }; 65 66 class BatchResultValues 67 { 68 public: 69 BatchResultValues (const vector<string>& tagNames) 70 : m_tagNames(tagNames) 71 { 72 } 73 74 ~BatchResultValues (void) 75 { 76 for (vector<CaseValues*>::iterator i = m_caseValues.begin(); i != m_caseValues.end(); ++i) 77 delete *i; 78 } 79 80 void add (const CaseValues& result) 81 { 82 CaseValues* copy = new CaseValues(result); 83 try 84 { 85 m_caseValues.push_back(copy); 86 } 87 catch (...) 88 { 89 delete copy; 90 throw; 91 } 92 } 93 94 const vector<string>& getTagNames (void) const { return m_tagNames; } 95 96 size_t size (void) const { return m_caseValues.size(); } 97 const CaseValues& operator[] (size_t ndx) const { return *m_caseValues[ndx]; } 98 99 private: 100 vector<string> m_tagNames; 101 vector<CaseValues*> m_caseValues; 102 }; 103 104 static Value findValueByTag (const xe::ri::List& items, const string& tagName) 105 { 106 for (int ndx = 0; ndx < items.getNumItems(); ndx++) 107 { 108 const xe::ri::Item& item = items.getItem(ndx); 109 110 if (item.getType() == xe::ri::TYPE_SECTION) 111 { 112 const Value value = findValueByTag(static_cast<const xe::ri::Section&>(item).items, tagName); 113 if (value.getType() != Value::TYPE_EMPTY) 114 return value; 115 } 116 else if (item.getType() == xe::ri::TYPE_NUMBER) 117 { 118 const xe::ri::Number& value = static_cast<const xe::ri::Number&>(item); 119 return value.value; 120 } 121 } 122 123 return Value(); 124 } 125 126 class TagParser : public xe::TestLogHandler 127 { 128 public: 129 TagParser (BatchResultValues& result) 130 : m_result(result) 131 { 132 } 133 134 void setSessionInfo (const xe::SessionInfo&) 135 { 136 // Ignored. 137 } 138 139 xe::TestCaseResultPtr startTestCaseResult (const char* casePath) 140 { 141 return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath)); 142 } 143 144 void testCaseResultUpdated (const xe::TestCaseResultPtr&) 145 { 146 // Ignored. 147 } 148 149 void testCaseResultComplete (const xe::TestCaseResultPtr& caseData) 150 { 151 const vector<string>& tagNames = m_result.getTagNames(); 152 CaseValues tagResult; 153 154 tagResult.casePath = caseData->getTestCasePath(); 155 tagResult.caseType = xe::TESTCASETYPE_SELF_VALIDATE; 156 tagResult.statusCode = caseData->getStatusCode(); 157 tagResult.statusDetails = caseData->getStatusDetails(); 158 tagResult.values.resize(tagNames.size()); 159 160 if (caseData->getDataSize() > 0 && caseData->getStatusCode() == xe::TESTSTATUSCODE_LAST) 161 { 162 xe::TestCaseResult fullResult; 163 xe::TestResultParser::ParseResult parseResult; 164 165 m_testResultParser.init(&fullResult); 166 parseResult = m_testResultParser.parse(caseData->getData(), caseData->getDataSize()); 167 168 if ((parseResult != xe::TestResultParser::PARSERESULT_ERROR && fullResult.statusCode != xe::TESTSTATUSCODE_LAST) || 169 (tagResult.statusCode == xe::TESTSTATUSCODE_LAST && fullResult.statusCode != xe::TESTSTATUSCODE_LAST)) 170 { 171 tagResult.statusCode = fullResult.statusCode; 172 tagResult.statusDetails = fullResult.statusDetails; 173 } 174 else if (tagResult.statusCode == xe::TESTSTATUSCODE_LAST) 175 { 176 DE_ASSERT(parseResult == xe::TestResultParser::PARSERESULT_ERROR); 177 tagResult.statusCode = xe::TESTSTATUSCODE_INTERNAL_ERROR; 178 tagResult.statusDetails = "Test case result parsing failed"; 179 } 180 181 if (parseResult != xe::TestResultParser::PARSERESULT_ERROR) 182 { 183 for (int valNdx = 0; valNdx < (int)tagNames.size(); valNdx++) 184 tagResult.values[valNdx] = findValueByTag(fullResult.resultItems, tagNames[valNdx]); 185 } 186 } 187 188 m_result.add(tagResult); 189 } 190 191 private: 192 BatchResultValues& m_result; 193 xe::TestResultParser m_testResultParser; 194 }; 195 196 static void readLogFile (BatchResultValues& batchResult, const char* filename) 197 { 198 std::ifstream in (filename, std::ifstream::binary|std::ifstream::in); 199 TagParser resultHandler (batchResult); 200 xe::TestLogParser parser (&resultHandler); 201 deUint8 buf [1024]; 202 int numRead = 0; 203 204 if (!in.good()) 205 throw std::runtime_error(string("Failed to open '") + filename + "'"); 206 207 for (;;) 208 { 209 in.read((char*)&buf[0], DE_LENGTH_OF_ARRAY(buf)); 210 numRead = (int)in.gcount(); 211 212 if (numRead <= 0) 213 break; 214 215 parser.parse(&buf[0], numRead); 216 } 217 218 in.close(); 219 } 220 221 static void printTaggedValues (const CommandLine& cmdLine, std::ostream& dst) 222 { 223 BatchResultValues values(cmdLine.tagNames); 224 225 readLogFile(values, cmdLine.filename.c_str()); 226 227 // Header 228 { 229 dst << "CasePath"; 230 if (cmdLine.statusCode) 231 dst << ",StatusCode"; 232 233 for (vector<string>::const_iterator tagName = values.getTagNames().begin(); tagName != values.getTagNames().end(); ++tagName) 234 dst << "," << *tagName; 235 236 dst << "\n"; 237 } 238 239 for (int resultNdx = 0; resultNdx < (int)values.size(); resultNdx++) 240 { 241 const CaseValues& result = values[resultNdx]; 242 243 dst << result.casePath; 244 if (cmdLine.statusCode) 245 dst << "," << xe::getTestStatusCodeName(result.statusCode); 246 247 for (vector<Value>::const_iterator value = result.values.begin(); value != result.values.end(); ++value) 248 dst << "," << *value; 249 250 dst << "\n"; 251 } 252 } 253 254 static void printHelp (const char* binName) 255 { 256 printf("%s: [filename] [name 1] [[name 2]...]\n", binName); 257 printf(" --statuscode Include status code as first entry.\n"); 258 } 259 260 static bool parseCommandLine (CommandLine& cmdLine, int argc, const char* const* argv) 261 { 262 for (int argNdx = 1; argNdx < argc; argNdx++) 263 { 264 const char* arg = argv[argNdx]; 265 266 if (deStringEqual(arg, "--statuscode")) 267 cmdLine.statusCode = true; 268 else if (!deStringBeginsWith(arg, "--")) 269 { 270 if (cmdLine.filename.empty()) 271 cmdLine.filename = arg; 272 else 273 cmdLine.tagNames.push_back(arg); 274 } 275 else 276 return false; 277 } 278 279 if (cmdLine.filename.empty()) 280 return false; 281 282 return true; 283 } 284 285 int main (int argc, const char* const* argv) 286 { 287 try 288 { 289 CommandLine cmdLine; 290 291 if (!parseCommandLine(cmdLine, argc, argv)) 292 { 293 printHelp(argv[0]); 294 return -1; 295 } 296 297 printTaggedValues(cmdLine, std::cout); 298 } 299 catch (const std::exception& e) 300 { 301 printf("FATAL ERROR: %s\n", e.what()); 302 return -1; 303 } 304 305 return 0; 306 } 307
