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 Batch result to XML export. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "xeTestLogParser.hpp" 25 #include "xeTestResultParser.hpp" 26 #include "xeXMLWriter.hpp" 27 #include "xeTestLogWriter.hpp" 28 #include "deFilePath.hpp" 29 #include "deString.h" 30 #include "deStringUtil.hpp" 31 #include "deCommandLine.hpp" 32 33 #include <vector> 34 #include <string> 35 #include <map> 36 #include <cstdio> 37 #include <fstream> 38 #include <iostream> 39 40 using std::vector; 41 using std::string; 42 using std::map; 43 44 static const char* CASELIST_STYLESHEET = "caselist.xsl"; 45 static const char* TESTCASE_STYLESHEET = "testlog.xsl"; 46 47 enum OutputMode 48 { 49 OUTPUTMODE_SEPARATE = 0, //!< Separate 50 OUTPUTMODE_SINGLE, 51 52 OUTPUTMODE_LAST 53 }; 54 55 namespace opt 56 { 57 58 DE_DECLARE_COMMAND_LINE_OPT(OutMode, OutputMode); 59 60 void registerOptions (de::cmdline::Parser& parser) 61 { 62 using de::cmdline::Option; 63 using de::cmdline::NamedValue; 64 65 static const NamedValue<OutputMode> s_modes[] = 66 { 67 { "single", OUTPUTMODE_SINGLE }, 68 { "separate", OUTPUTMODE_SEPARATE } 69 }; 70 71 parser << Option<OutMode>("m", "mode", "Output mode", s_modes, "single"); 72 } 73 74 } // opt 75 76 struct CommandLine 77 { 78 CommandLine (void) 79 : outputMode(OUTPUTMODE_SINGLE) 80 { 81 } 82 83 std::string batchResultFile; 84 std::string outputPath; 85 OutputMode outputMode; 86 }; 87 88 static bool parseCommandLine (CommandLine& cmdLine, int argc, const char* const* argv) 89 { 90 de::cmdline::Parser parser; 91 de::cmdline::CommandLine opts; 92 93 opt::registerOptions(parser); 94 95 if (!parser.parse(argc-1, argv+1, &opts, std::cerr) || 96 opts.getArgs().size() != 2) 97 { 98 printf("%s: [options] [testlog] [destination path]\n", argv[0]); 99 parser.help(std::cout); 100 return false; 101 } 102 103 cmdLine.outputMode = opts.getOption<opt::OutMode>(); 104 cmdLine.batchResultFile = opts.getArgs()[0]; 105 cmdLine.outputPath = opts.getArgs()[1]; 106 107 return true; 108 } 109 110 static void parseBatchResult (xe::TestLogParser& parser, const char* filename) 111 { 112 std::ifstream in (filename, std::ios_base::binary); 113 deUint8 buf[2048]; 114 115 for (;;) 116 { 117 in.read((char*)&buf[0], sizeof(buf)); 118 int numRead = (int)in.gcount(); 119 120 if (numRead > 0) 121 parser.parse(&buf[0], numRead); 122 123 if (numRead < (int)sizeof(buf)) 124 break; 125 } 126 } 127 128 // Export to single file 129 130 struct BatchResultTotals 131 { 132 BatchResultTotals (void) 133 { 134 for (int i = 0;i < xe::TESTSTATUSCODE_LAST; i++) 135 countByCode[i] = 0; 136 } 137 138 int countByCode[xe::TESTSTATUSCODE_LAST]; 139 }; 140 141 class ResultToSingleXmlLogHandler : public xe::TestLogHandler 142 { 143 public: 144 ResultToSingleXmlLogHandler (xe::xml::Writer& writer, BatchResultTotals& totals) 145 : m_writer (writer) 146 , m_totals (totals) 147 { 148 } 149 150 void setSessionInfo (const xe::SessionInfo&) 151 { 152 } 153 154 xe::TestCaseResultPtr startTestCaseResult (const char* casePath) 155 { 156 return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath)); 157 } 158 159 void testCaseResultUpdated (const xe::TestCaseResultPtr&) 160 { 161 } 162 163 void testCaseResultComplete (const xe::TestCaseResultPtr& resultData) 164 { 165 xe::TestCaseResult result; 166 167 xe::parseTestCaseResultFromData(&m_resultParser, &result, *resultData.get()); 168 169 // Write result. 170 xe::writeTestResult(result, m_writer); 171 172 // Record total 173 XE_CHECK(de::inBounds<int>(result.statusCode, 0, xe::TESTSTATUSCODE_LAST)); 174 m_totals.countByCode[result.statusCode] += 1; 175 } 176 177 private: 178 xe::xml::Writer& m_writer; 179 BatchResultTotals& m_totals; 180 xe::TestResultParser m_resultParser; 181 }; 182 183 static void writeTotals (xe::xml::Writer& writer, const BatchResultTotals& totals) 184 { 185 using xe::xml::Writer; 186 187 int totalCases = 0; 188 189 writer << Writer::BeginElement("ResultTotals"); 190 191 for (int code = 0; code < xe::TESTSTATUSCODE_LAST; code++) 192 { 193 writer << Writer::Attribute(xe::getTestStatusCodeName((xe::TestStatusCode)code), de::toString(totals.countByCode[code]).c_str()); 194 totalCases += totals.countByCode[code]; 195 } 196 197 writer << Writer::Attribute("All", de::toString(totalCases).c_str()) 198 << Writer::EndElement; 199 } 200 201 static void batchResultToSingleXmlFile (const char* batchResultFilename, const char* dstFileName) 202 { 203 std::ofstream out (dstFileName, std::ios_base::binary); 204 xe::xml::Writer writer (out); 205 BatchResultTotals totals; 206 ResultToSingleXmlLogHandler handler (writer, totals); 207 xe::TestLogParser parser (&handler); 208 209 XE_CHECK(out.good()); 210 211 out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" 212 << "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n"; 213 214 writer << xe::xml::Writer::BeginElement("BatchResult") 215 << xe::xml::Writer::Attribute("FileName", de::FilePath(batchResultFilename).getBaseName()); 216 217 // Parse and write individual cases 218 parseBatchResult(parser, batchResultFilename); 219 220 // Write ResultTotals 221 writeTotals(writer, totals); 222 223 writer << xe::xml::Writer::EndElement; 224 out << "\n"; 225 } 226 227 // Export to separate files 228 229 class ResultToXmlFilesLogHandler : public xe::TestLogHandler 230 { 231 public: 232 ResultToXmlFilesLogHandler (vector<xe::TestCaseResultHeader>& resultHeaders, const char* dstPath) 233 : m_resultHeaders (resultHeaders) 234 , m_dstPath (dstPath) 235 { 236 } 237 238 void setSessionInfo (const xe::SessionInfo&) 239 { 240 } 241 242 xe::TestCaseResultPtr startTestCaseResult (const char* casePath) 243 { 244 return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath)); 245 } 246 247 void testCaseResultUpdated (const xe::TestCaseResultPtr&) 248 { 249 } 250 251 void testCaseResultComplete (const xe::TestCaseResultPtr& resultData) 252 { 253 xe::TestCaseResult result; 254 255 xe::parseTestCaseResultFromData(&m_resultParser, &result, *resultData.get()); 256 257 // Write result. 258 { 259 de::FilePath casePath = de::FilePath::join(m_dstPath, (result.casePath + ".xml").c_str()); 260 std::ofstream out (casePath.getPath(), std::ofstream::binary|std::ofstream::trunc); 261 xe::xml::Writer xmlWriter (out); 262 263 if (!out.good()) 264 throw xe::Error(string("Failed to open ") + casePath.getPath()); 265 266 out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" 267 << "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n"; 268 xe::writeTestResult(result, xmlWriter); 269 out << "\n"; 270 } 271 272 m_resultHeaders.push_back(xe::TestCaseResultHeader(result)); 273 } 274 275 private: 276 vector<xe::TestCaseResultHeader>& m_resultHeaders; 277 std::string m_dstPath; 278 xe::TestResultParser m_resultParser; 279 }; 280 281 typedef std::map<const xe::TestCase*, const xe::TestCaseResultHeader*> ShortTestResultMap; 282 283 static void writeTestCaseListNode (const xe::TestNode* testNode, const ShortTestResultMap& resultMap, xe::xml::Writer& dst) 284 { 285 using xe::xml::Writer; 286 287 bool isGroup = testNode->getNodeType() == xe::TESTNODETYPE_GROUP; 288 string fullPath; 289 testNode->getFullPath(fullPath); 290 291 if (isGroup) 292 { 293 const xe::TestGroup* group = static_cast<const xe::TestGroup*>(testNode); 294 295 dst << Writer::BeginElement("TestGroup") 296 << Writer::Attribute("Name", testNode->getName()); 297 298 for (int childNdx = 0; childNdx < group->getNumChildren(); childNdx++) 299 writeTestCaseListNode(group->getChild(childNdx), resultMap, dst); 300 301 dst << Writer::EndElement; 302 } 303 else 304 { 305 DE_ASSERT(testNode->getNodeType() == xe::TESTNODETYPE_TEST_CASE); 306 307 const xe::TestCase* testCase = static_cast<const xe::TestCase*>(testNode); 308 ShortTestResultMap::const_iterator resultPos = resultMap.find(testCase); 309 const xe::TestCaseResultHeader* result = resultPos != resultMap.end() ? resultPos->second : DE_NULL; 310 311 DE_ASSERT(result); 312 313 dst << Writer::BeginElement("TestCase") 314 << Writer::Attribute("Name", testNode->getName()) 315 << Writer::Attribute("Type", xe::getTestCaseTypeName(result->caseType)) 316 << Writer::Attribute("StatusCode", xe::getTestStatusCodeName(result->statusCode)) 317 << Writer::Attribute("StatusDetails", result->statusDetails.c_str()) 318 << Writer::EndElement; 319 } 320 } 321 322 static void writeTestCaseList (const xe::TestRoot& root, const ShortTestResultMap& resultMap, xe::xml::Writer& dst) 323 { 324 using xe::xml::Writer; 325 326 dst << Writer::BeginElement("TestRoot"); 327 328 for (int childNdx = 0; childNdx < root.getNumChildren(); childNdx++) 329 writeTestCaseListNode(root.getChild(childNdx), resultMap, dst); 330 331 dst << Writer::EndElement; 332 } 333 334 static void batchResultToSeparateXmlFiles (const char* batchResultFilename, const char* dstPath) 335 { 336 xe::TestRoot testRoot; 337 vector<xe::TestCaseResultHeader> shortResults; 338 ShortTestResultMap resultMap; 339 340 // Initialize destination directory. 341 if (!de::FilePath(dstPath).exists()) 342 de::createDirectoryAndParents(dstPath); 343 else 344 XE_CHECK_MSG(de::FilePath(dstPath).getType() == de::FilePath::TYPE_DIRECTORY, "Destination is not directory"); 345 346 // Parse batch result and write out test cases. 347 { 348 ResultToXmlFilesLogHandler handler (shortResults, dstPath); 349 xe::TestLogParser parser (&handler); 350 351 parseBatchResult(parser, batchResultFilename); 352 } 353 354 // Build case hierarchy & short result map. 355 { 356 xe::TestHierarchyBuilder hierarchyBuilder(&testRoot); 357 358 for (vector<xe::TestCaseResultHeader>::const_iterator result = shortResults.begin(); result != shortResults.end(); result++) 359 { 360 xe::TestCase* testCase = hierarchyBuilder.createCase(result->casePath.c_str(), result->caseType); 361 resultMap.insert(std::make_pair(testCase, &(*result))); 362 } 363 } 364 365 // Create caselist. 366 { 367 de::FilePath indexPath = de::FilePath::join(dstPath, "caselist.xml"); 368 std::ofstream out (indexPath.getPath(), std::ofstream::binary|std::ofstream::trunc); 369 xe::xml::Writer xmlWriter (out); 370 371 XE_CHECK_MSG(out.good(), "Failed to open caselist.xml"); 372 373 out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" 374 << "<?xml-stylesheet href=\"" << CASELIST_STYLESHEET << "\" type=\"text/xsl\"?>\n"; 375 writeTestCaseList(testRoot, resultMap, xmlWriter); 376 out << "\n"; 377 } 378 } 379 380 int main (int argc, const char* const* argv) 381 { 382 try 383 { 384 CommandLine cmdLine; 385 if (!parseCommandLine(cmdLine, argc, argv)) 386 return -1; 387 388 if (cmdLine.outputMode == OUTPUTMODE_SINGLE) 389 batchResultToSingleXmlFile(cmdLine.batchResultFile.c_str(), cmdLine.outputPath.c_str()); 390 else 391 batchResultToSeparateXmlFiles(cmdLine.batchResultFile.c_str(), cmdLine.outputPath.c_str()); 392 } 393 catch (const std::exception& e) 394 { 395 printf("%s\n", e.what()); 396 return -1; 397 } 398 399 return 0; 400 } 401
