blob: 509f6f7036169f58083270fd09da881e62b4c6d2 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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;
}