/*-------------------------------------------------------------------------
|
* 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 Batch result to XML export.
|
*//*--------------------------------------------------------------------*/
|
|
#include "xeTestLogParser.hpp"
|
#include "xeTestResultParser.hpp"
|
#include "xeXMLWriter.hpp"
|
#include "xeTestLogWriter.hpp"
|
#include "deFilePath.hpp"
|
#include "deString.h"
|
#include "deStringUtil.hpp"
|
#include "deCommandLine.hpp"
|
|
#include <vector>
|
#include <string>
|
#include <map>
|
#include <cstdio>
|
#include <fstream>
|
#include <iostream>
|
|
using std::vector;
|
using std::string;
|
using std::map;
|
|
static const char* CASELIST_STYLESHEET = "caselist.xsl";
|
static const char* TESTCASE_STYLESHEET = "testlog.xsl";
|
|
enum OutputMode
|
{
|
OUTPUTMODE_SEPARATE = 0, //!< Separate
|
OUTPUTMODE_SINGLE,
|
|
OUTPUTMODE_LAST
|
};
|
|
namespace opt
|
{
|
|
DE_DECLARE_COMMAND_LINE_OPT(OutMode, OutputMode);
|
|
void registerOptions (de::cmdline::Parser& parser)
|
{
|
using de::cmdline::Option;
|
using de::cmdline::NamedValue;
|
|
static const NamedValue<OutputMode> s_modes[] =
|
{
|
{ "single", OUTPUTMODE_SINGLE },
|
{ "separate", OUTPUTMODE_SEPARATE }
|
};
|
|
parser << Option<OutMode>("m", "mode", "Output mode", s_modes, "single");
|
}
|
|
} // opt
|
|
struct CommandLine
|
{
|
CommandLine (void)
|
: outputMode(OUTPUTMODE_SINGLE)
|
{
|
}
|
|
std::string batchResultFile;
|
std::string outputPath;
|
OutputMode outputMode;
|
};
|
|
static bool parseCommandLine (CommandLine& cmdLine, int argc, const char* const* argv)
|
{
|
de::cmdline::Parser parser;
|
de::cmdline::CommandLine opts;
|
|
opt::registerOptions(parser);
|
|
if (!parser.parse(argc-1, argv+1, &opts, std::cerr) ||
|
opts.getArgs().size() != 2)
|
{
|
printf("%s: [options] [testlog] [destination path]\n", argv[0]);
|
parser.help(std::cout);
|
return false;
|
}
|
|
cmdLine.outputMode = opts.getOption<opt::OutMode>();
|
cmdLine.batchResultFile = opts.getArgs()[0];
|
cmdLine.outputPath = opts.getArgs()[1];
|
|
return true;
|
}
|
|
static void parseBatchResult (xe::TestLogParser& parser, const char* filename)
|
{
|
std::ifstream in (filename, std::ios_base::binary);
|
deUint8 buf[2048];
|
|
for (;;)
|
{
|
in.read((char*)&buf[0], sizeof(buf));
|
int numRead = (int)in.gcount();
|
|
if (numRead > 0)
|
parser.parse(&buf[0], numRead);
|
|
if (numRead < (int)sizeof(buf))
|
break;
|
}
|
}
|
|
// Export to single file
|
|
struct BatchResultTotals
|
{
|
BatchResultTotals (void)
|
{
|
for (int i = 0;i < xe::TESTSTATUSCODE_LAST; i++)
|
countByCode[i] = 0;
|
}
|
|
int countByCode[xe::TESTSTATUSCODE_LAST];
|
};
|
|
class ResultToSingleXmlLogHandler : public xe::TestLogHandler
|
{
|
public:
|
ResultToSingleXmlLogHandler (xe::xml::Writer& writer, BatchResultTotals& totals)
|
: m_writer (writer)
|
, m_totals (totals)
|
{
|
}
|
|
void setSessionInfo (const xe::SessionInfo&)
|
{
|
}
|
|
xe::TestCaseResultPtr startTestCaseResult (const char* casePath)
|
{
|
return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath));
|
}
|
|
void testCaseResultUpdated (const xe::TestCaseResultPtr&)
|
{
|
}
|
|
void testCaseResultComplete (const xe::TestCaseResultPtr& resultData)
|
{
|
xe::TestCaseResult result;
|
|
xe::parseTestCaseResultFromData(&m_resultParser, &result, *resultData.get());
|
|
// Write result.
|
xe::writeTestResult(result, m_writer);
|
|
// Record total
|
XE_CHECK(de::inBounds<int>(result.statusCode, 0, xe::TESTSTATUSCODE_LAST));
|
m_totals.countByCode[result.statusCode] += 1;
|
}
|
|
private:
|
xe::xml::Writer& m_writer;
|
BatchResultTotals& m_totals;
|
xe::TestResultParser m_resultParser;
|
};
|
|
static void writeTotals (xe::xml::Writer& writer, const BatchResultTotals& totals)
|
{
|
using xe::xml::Writer;
|
|
int totalCases = 0;
|
|
writer << Writer::BeginElement("ResultTotals");
|
|
for (int code = 0; code < xe::TESTSTATUSCODE_LAST; code++)
|
{
|
writer << Writer::Attribute(xe::getTestStatusCodeName((xe::TestStatusCode)code), de::toString(totals.countByCode[code]).c_str());
|
totalCases += totals.countByCode[code];
|
}
|
|
writer << Writer::Attribute("All", de::toString(totalCases).c_str())
|
<< Writer::EndElement;
|
}
|
|
static void batchResultToSingleXmlFile (const char* batchResultFilename, const char* dstFileName)
|
{
|
std::ofstream out (dstFileName, std::ios_base::binary);
|
xe::xml::Writer writer (out);
|
BatchResultTotals totals;
|
ResultToSingleXmlLogHandler handler (writer, totals);
|
xe::TestLogParser parser (&handler);
|
|
XE_CHECK(out.good());
|
|
out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
|
<< "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n";
|
|
writer << xe::xml::Writer::BeginElement("BatchResult")
|
<< xe::xml::Writer::Attribute("FileName", de::FilePath(batchResultFilename).getBaseName());
|
|
// Parse and write individual cases
|
parseBatchResult(parser, batchResultFilename);
|
|
// Write ResultTotals
|
writeTotals(writer, totals);
|
|
writer << xe::xml::Writer::EndElement;
|
out << "\n";
|
}
|
|
// Export to separate files
|
|
class ResultToXmlFilesLogHandler : public xe::TestLogHandler
|
{
|
public:
|
ResultToXmlFilesLogHandler (vector<xe::TestCaseResultHeader>& resultHeaders, const char* dstPath)
|
: m_resultHeaders (resultHeaders)
|
, m_dstPath (dstPath)
|
{
|
}
|
|
void setSessionInfo (const xe::SessionInfo&)
|
{
|
}
|
|
xe::TestCaseResultPtr startTestCaseResult (const char* casePath)
|
{
|
return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath));
|
}
|
|
void testCaseResultUpdated (const xe::TestCaseResultPtr&)
|
{
|
}
|
|
void testCaseResultComplete (const xe::TestCaseResultPtr& resultData)
|
{
|
xe::TestCaseResult result;
|
|
xe::parseTestCaseResultFromData(&m_resultParser, &result, *resultData.get());
|
|
// Write result.
|
{
|
de::FilePath casePath = de::FilePath::join(m_dstPath, (result.casePath + ".xml").c_str());
|
std::ofstream out (casePath.getPath(), std::ofstream::binary|std::ofstream::trunc);
|
xe::xml::Writer xmlWriter (out);
|
|
if (!out.good())
|
throw xe::Error(string("Failed to open ") + casePath.getPath());
|
|
out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
|
<< "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n";
|
xe::writeTestResult(result, xmlWriter);
|
out << "\n";
|
}
|
|
m_resultHeaders.push_back(xe::TestCaseResultHeader(result));
|
}
|
|
private:
|
vector<xe::TestCaseResultHeader>& m_resultHeaders;
|
std::string m_dstPath;
|
xe::TestResultParser m_resultParser;
|
};
|
|
typedef std::map<const xe::TestCase*, const xe::TestCaseResultHeader*> ShortTestResultMap;
|
|
static void writeTestCaseListNode (const xe::TestNode* testNode, const ShortTestResultMap& resultMap, xe::xml::Writer& dst)
|
{
|
using xe::xml::Writer;
|
|
bool isGroup = testNode->getNodeType() == xe::TESTNODETYPE_GROUP;
|
string fullPath;
|
testNode->getFullPath(fullPath);
|
|
if (isGroup)
|
{
|
const xe::TestGroup* group = static_cast<const xe::TestGroup*>(testNode);
|
|
dst << Writer::BeginElement("TestGroup")
|
<< Writer::Attribute("Name", testNode->getName());
|
|
for (int childNdx = 0; childNdx < group->getNumChildren(); childNdx++)
|
writeTestCaseListNode(group->getChild(childNdx), resultMap, dst);
|
|
dst << Writer::EndElement;
|
}
|
else
|
{
|
DE_ASSERT(testNode->getNodeType() == xe::TESTNODETYPE_TEST_CASE);
|
|
const xe::TestCase* testCase = static_cast<const xe::TestCase*>(testNode);
|
ShortTestResultMap::const_iterator resultPos = resultMap.find(testCase);
|
const xe::TestCaseResultHeader* result = resultPos != resultMap.end() ? resultPos->second : DE_NULL;
|
|
DE_ASSERT(result);
|
|
dst << Writer::BeginElement("TestCase")
|
<< Writer::Attribute("Name", testNode->getName())
|
<< Writer::Attribute("Type", xe::getTestCaseTypeName(result->caseType))
|
<< Writer::Attribute("StatusCode", xe::getTestStatusCodeName(result->statusCode))
|
<< Writer::Attribute("StatusDetails", result->statusDetails.c_str())
|
<< Writer::EndElement;
|
}
|
}
|
|
static void writeTestCaseList (const xe::TestRoot& root, const ShortTestResultMap& resultMap, xe::xml::Writer& dst)
|
{
|
using xe::xml::Writer;
|
|
dst << Writer::BeginElement("TestRoot");
|
|
for (int childNdx = 0; childNdx < root.getNumChildren(); childNdx++)
|
writeTestCaseListNode(root.getChild(childNdx), resultMap, dst);
|
|
dst << Writer::EndElement;
|
}
|
|
static void batchResultToSeparateXmlFiles (const char* batchResultFilename, const char* dstPath)
|
{
|
xe::TestRoot testRoot;
|
vector<xe::TestCaseResultHeader> shortResults;
|
ShortTestResultMap resultMap;
|
|
// Initialize destination directory.
|
if (!de::FilePath(dstPath).exists())
|
de::createDirectoryAndParents(dstPath);
|
else
|
XE_CHECK_MSG(de::FilePath(dstPath).getType() == de::FilePath::TYPE_DIRECTORY, "Destination is not directory");
|
|
// Parse batch result and write out test cases.
|
{
|
ResultToXmlFilesLogHandler handler (shortResults, dstPath);
|
xe::TestLogParser parser (&handler);
|
|
parseBatchResult(parser, batchResultFilename);
|
}
|
|
// Build case hierarchy & short result map.
|
{
|
xe::TestHierarchyBuilder hierarchyBuilder(&testRoot);
|
|
for (vector<xe::TestCaseResultHeader>::const_iterator result = shortResults.begin(); result != shortResults.end(); result++)
|
{
|
xe::TestCase* testCase = hierarchyBuilder.createCase(result->casePath.c_str(), result->caseType);
|
resultMap.insert(std::make_pair(testCase, &(*result)));
|
}
|
}
|
|
// Create caselist.
|
{
|
de::FilePath indexPath = de::FilePath::join(dstPath, "caselist.xml");
|
std::ofstream out (indexPath.getPath(), std::ofstream::binary|std::ofstream::trunc);
|
xe::xml::Writer xmlWriter (out);
|
|
XE_CHECK_MSG(out.good(), "Failed to open caselist.xml");
|
|
out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
|
<< "<?xml-stylesheet href=\"" << CASELIST_STYLESHEET << "\" type=\"text/xsl\"?>\n";
|
writeTestCaseList(testRoot, resultMap, xmlWriter);
|
out << "\n";
|
}
|
}
|
|
int main (int argc, const char* const* argv)
|
{
|
try
|
{
|
CommandLine cmdLine;
|
if (!parseCommandLine(cmdLine, argc, argv))
|
return -1;
|
|
if (cmdLine.outputMode == OUTPUTMODE_SINGLE)
|
batchResultToSingleXmlFile(cmdLine.batchResultFile.c_str(), cmdLine.outputPath.c_str());
|
else
|
batchResultToSeparateXmlFiles(cmdLine.batchResultFile.c_str(), cmdLine.outputPath.c_str());
|
}
|
catch (const std::exception& e)
|
{
|
printf("%s\n", e.what());
|
return -1;
|
}
|
|
return 0;
|
}
|
